2 * QEMU model of the Milkymist minimac block.
4 * Copyright (c) 2010 Michael Walle <michael@walle.cc>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 * Specification available at:
21 * http://www.milkymist.org/socdoc/minimac.pdf
29 #include "qemu-error.h"
54 SETUP_RX_RST
= (1<<0),
55 SETUP_TX_RST
= (1<<2),
88 #define MINIMAC_MTU 1530
90 struct MilkymistMinimacMdioState
{
100 typedef struct MilkymistMinimacMdioState MilkymistMinimacMdioState
;
102 struct MilkymistMinimacState
{
111 uint32_t regs
[R_MAX
];
113 MilkymistMinimacMdioState mdio
;
115 uint16_t phy_regs
[R_PHY_MAX
];
117 typedef struct MilkymistMinimacState MilkymistMinimacState
;
119 static const uint8_t preamble_sfd
[] = {
120 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xd5
123 static void minimac_mdio_write_reg(MilkymistMinimacState
*s
,
124 uint8_t phy_addr
, uint8_t reg_addr
, uint16_t value
)
126 trace_milkymist_minimac_mdio_write(phy_addr
, reg_addr
, value
);
131 static uint16_t minimac_mdio_read_reg(MilkymistMinimacState
*s
,
132 uint8_t phy_addr
, uint8_t reg_addr
)
134 uint16_t r
= s
->phy_regs
[reg_addr
];
136 trace_milkymist_minimac_mdio_read(phy_addr
, reg_addr
, r
);
141 static void minimac_update_mdio(MilkymistMinimacState
*s
)
143 MilkymistMinimacMdioState
*m
= &s
->mdio
;
145 /* detect rising clk edge */
146 if (m
->last_clk
== 0 && (s
->regs
[R_MDIO
] & MDIO_CLK
)) {
148 int bit
= ((s
->regs
[R_MDIO
] & MDIO_DO
)
149 && (s
->regs
[R_MDIO
] & MDIO_OE
)) ? 1 : 0;
150 m
->data
= (m
->data
<< 1) | bit
;
153 if (m
->data
== 0xffffffff) {
157 if (m
->count
== 16) {
158 uint8_t start
= (m
->data
>> 14) & 0x3;
159 uint8_t op
= (m
->data
>> 12) & 0x3;
160 uint8_t ta
= (m
->data
) & 0x3;
162 if (start
== 1 && op
== MDIO_OP_WRITE
&& ta
== 2) {
163 m
->state
= MDIO_STATE_WRITING
;
164 } else if (start
== 1 && op
== MDIO_OP_READ
&& (ta
& 1) == 0) {
165 m
->state
= MDIO_STATE_READING
;
167 m
->state
= MDIO_STATE_IDLE
;
170 if (m
->state
!= MDIO_STATE_IDLE
) {
171 m
->phy_addr
= (m
->data
>> 7) & 0x1f;
172 m
->reg_addr
= (m
->data
>> 2) & 0x1f;
175 if (m
->state
== MDIO_STATE_READING
) {
176 m
->data_out
= minimac_mdio_read_reg(s
, m
->phy_addr
,
181 if (m
->count
< 16 && m
->state
== MDIO_STATE_READING
) {
182 int bit
= (m
->data_out
& 0x8000) ? 1 : 0;
186 s
->regs
[R_MDIO
] |= MDIO_DI
;
188 s
->regs
[R_MDIO
] &= ~MDIO_DI
;
192 if (m
->count
== 0 && m
->state
) {
193 if (m
->state
== MDIO_STATE_WRITING
) {
194 uint16_t data
= m
->data
& 0xffff;
195 minimac_mdio_write_reg(s
, m
->phy_addr
, m
->reg_addr
, data
);
197 m
->state
= MDIO_STATE_IDLE
;
202 m
->last_clk
= (s
->regs
[R_MDIO
] & MDIO_CLK
) ? 1 : 0;
205 static size_t assemble_frame(uint8_t *buf
, size_t size
,
206 const uint8_t *payload
, size_t payload_size
)
210 if (size
< payload_size
+ 12) {
211 error_report("milkymist_minimac: received too big ethernet frame");
215 /* prepend preamble and sfd */
216 memcpy(buf
, preamble_sfd
, 8);
218 /* now copy the payload */
219 memcpy(buf
+ 8, payload
, payload_size
);
221 /* pad frame if needed */
222 if (payload_size
< 60) {
223 memset(buf
+ payload_size
+ 8, 0, 60 - payload_size
);
228 crc
= cpu_to_le32(crc32(0, buf
+ 8, payload_size
));
229 memcpy(buf
+ payload_size
+ 8, &crc
, 4);
231 return payload_size
+ 12;
234 static void minimac_tx(MilkymistMinimacState
*s
)
236 uint8_t buf
[MINIMAC_MTU
];
237 uint32_t txcount
= s
->regs
[R_TXCOUNT
];
239 /* do nothing if transmission logic is in reset */
240 if (s
->regs
[R_SETUP
] & SETUP_TX_RST
) {
245 error_report("milkymist_minimac: ethernet frame too small (%u < %u)\n",
250 if (txcount
> MINIMAC_MTU
) {
251 error_report("milkymist_minimac: MTU exceeded (%u > %u)\n",
252 txcount
, MINIMAC_MTU
);
257 cpu_physical_memory_read(s
->regs
[R_TXADDR
], buf
, txcount
);
259 if (memcmp(buf
, preamble_sfd
, 8) != 0) {
260 error_report("milkymist_minimac: frame doesn't contain the preamble "
261 "and/or the SFD (%02x %02x %02x %02x %02x %02x %02x %02x)\n",
262 buf
[0], buf
[1], buf
[2], buf
[3], buf
[4], buf
[5], buf
[6], buf
[7]);
266 trace_milkymist_minimac_tx_frame(txcount
- 12);
268 /* send packet, skipping preamble and sfd */
269 qemu_send_packet_raw(&s
->nic
->nc
, buf
+ 8, txcount
- 12);
271 s
->regs
[R_TXCOUNT
] = 0;
273 trace_milkymist_minimac_pulse_irq_tx();
274 qemu_irq_pulse(s
->tx_irq
);
277 static ssize_t
minimac_rx(VLANClientState
*nc
, const uint8_t *buf
, size_t size
)
279 MilkymistMinimacState
*s
= DO_UPCAST(NICState
, nc
, nc
)->opaque
;
285 uint8_t frame_buf
[MINIMAC_MTU
];
288 trace_milkymist_minimac_rx_frame(buf
, size
);
290 /* discard frames if nic is in reset */
291 if (s
->regs
[R_SETUP
] & SETUP_RX_RST
) {
295 /* choose appropriate slot */
296 if (s
->regs
[R_STATE0
] == STATE_LOADED
) {
300 } else if (s
->regs
[R_STATE1
] == STATE_LOADED
) {
304 } else if (s
->regs
[R_STATE2
] == STATE_LOADED
) {
308 } else if (s
->regs
[R_STATE3
] == STATE_LOADED
) {
313 trace_milkymist_minimac_drop_rx_frame(buf
);
318 frame_size
= assemble_frame(frame_buf
, sizeof(frame_buf
), buf
, size
);
320 if (frame_size
== 0) {
324 trace_milkymist_minimac_rx_transfer(buf
, frame_size
);
327 cpu_physical_memory_write(s
->regs
[r_addr
], frame_buf
, frame_size
);
330 s
->regs
[r_count
] = frame_size
;
331 s
->regs
[r_state
] = STATE_PENDING
;
333 trace_milkymist_minimac_pulse_irq_rx();
334 qemu_irq_pulse(s
->rx_irq
);
340 minimac_read(void *opaque
, target_phys_addr_t addr
)
342 MilkymistMinimacState
*s
= opaque
;
367 error_report("milkymist_minimac: read access to unknown register 0x"
368 TARGET_FMT_plx
, addr
<< 2);
372 trace_milkymist_minimac_memory_read(addr
<< 2, r
);
378 minimac_write(void *opaque
, target_phys_addr_t addr
, uint32_t value
)
380 MilkymistMinimacState
*s
= opaque
;
382 trace_milkymist_minimac_memory_read(addr
, value
);
388 /* MDIO_DI is read only */
389 int mdio_di
= (s
->regs
[R_MDIO
] & MDIO_DI
);
390 s
->regs
[R_MDIO
] = value
;
392 s
->regs
[R_MDIO
] |= mdio_di
;
394 s
->regs
[R_MDIO
] &= ~mdio_di
;
397 minimac_update_mdio(s
);
400 s
->regs
[addr
] = value
;
419 s
->regs
[addr
] = value
;
423 error_report("milkymist_minimac: write access to unknown register 0x"
424 TARGET_FMT_plx
, addr
<< 2);
429 static CPUReadMemoryFunc
* const minimac_read_fn
[] = {
435 static CPUWriteMemoryFunc
* const minimac_write_fn
[] = {
441 static int minimac_can_rx(VLANClientState
*nc
)
443 MilkymistMinimacState
*s
= DO_UPCAST(NICState
, nc
, nc
)->opaque
;
445 /* discard frames if nic is in reset */
446 if (s
->regs
[R_SETUP
] & SETUP_RX_RST
) {
450 if (s
->regs
[R_STATE0
] == STATE_LOADED
) {
453 if (s
->regs
[R_STATE1
] == STATE_LOADED
) {
456 if (s
->regs
[R_STATE2
] == STATE_LOADED
) {
459 if (s
->regs
[R_STATE3
] == STATE_LOADED
) {
466 static void minimac_cleanup(VLANClientState
*nc
)
468 MilkymistMinimacState
*s
= DO_UPCAST(NICState
, nc
, nc
)->opaque
;
473 static void milkymist_minimac_reset(DeviceState
*d
)
475 MilkymistMinimacState
*s
=
476 container_of(d
, MilkymistMinimacState
, busdev
.qdev
);
479 for (i
= 0; i
< R_MAX
; i
++) {
482 for (i
= 0; i
< R_PHY_MAX
; i
++) {
487 s
->phy_regs
[R_PHY_ID1
] = 0x0022; /* Micrel KSZ8001L */
488 s
->phy_regs
[R_PHY_ID2
] = 0x161a;
491 static NetClientInfo net_milkymist_minimac_info
= {
492 .type
= NET_CLIENT_TYPE_NIC
,
493 .size
= sizeof(NICState
),
494 .can_receive
= minimac_can_rx
,
495 .receive
= minimac_rx
,
496 .cleanup
= minimac_cleanup
,
499 static int milkymist_minimac_init(SysBusDevice
*dev
)
501 MilkymistMinimacState
*s
= FROM_SYSBUS(typeof(*s
), dev
);
504 sysbus_init_irq(dev
, &s
->rx_irq
);
505 sysbus_init_irq(dev
, &s
->tx_irq
);
507 regs
= cpu_register_io_memory(minimac_read_fn
, minimac_write_fn
, s
,
508 DEVICE_NATIVE_ENDIAN
);
509 sysbus_init_mmio(dev
, R_MAX
* 4, regs
);
511 qemu_macaddr_default_if_unset(&s
->conf
.macaddr
);
512 s
->nic
= qemu_new_nic(&net_milkymist_minimac_info
, &s
->conf
,
513 dev
->qdev
.info
->name
, dev
->qdev
.id
, s
);
514 qemu_format_nic_info_str(&s
->nic
->nc
, s
->conf
.macaddr
.a
);
519 static const VMStateDescription vmstate_milkymist_minimac_mdio
= {
520 .name
= "milkymist_minimac_mdio",
522 .minimum_version_id
= 1,
523 .minimum_version_id_old
= 1,
524 .fields
= (VMStateField
[]) {
525 VMSTATE_INT32(last_clk
, MilkymistMinimacMdioState
),
526 VMSTATE_INT32(count
, MilkymistMinimacMdioState
),
527 VMSTATE_UINT32(data
, MilkymistMinimacMdioState
),
528 VMSTATE_UINT16(data_out
, MilkymistMinimacMdioState
),
529 VMSTATE_INT32(state
, MilkymistMinimacMdioState
),
530 VMSTATE_UINT8(phy_addr
, MilkymistMinimacMdioState
),
531 VMSTATE_UINT8(reg_addr
, MilkymistMinimacMdioState
),
532 VMSTATE_END_OF_LIST()
536 static const VMStateDescription vmstate_milkymist_minimac
= {
537 .name
= "milkymist-minimac",
539 .minimum_version_id
= 1,
540 .minimum_version_id_old
= 1,
541 .fields
= (VMStateField
[]) {
542 VMSTATE_UINT32_ARRAY(regs
, MilkymistMinimacState
, R_MAX
),
543 VMSTATE_UINT16_ARRAY(phy_regs
, MilkymistMinimacState
, R_PHY_MAX
),
544 VMSTATE_STRUCT(mdio
, MilkymistMinimacState
, 0,
545 vmstate_milkymist_minimac_mdio
, MilkymistMinimacMdioState
),
546 VMSTATE_END_OF_LIST()
550 static SysBusDeviceInfo milkymist_minimac_info
= {
551 .init
= milkymist_minimac_init
,
552 .qdev
.name
= "milkymist-minimac",
553 .qdev
.size
= sizeof(MilkymistMinimacState
),
554 .qdev
.vmsd
= &vmstate_milkymist_minimac
,
555 .qdev
.reset
= milkymist_minimac_reset
,
556 .qdev
.props
= (Property
[]) {
557 DEFINE_NIC_PROPERTIES(MilkymistMinimacState
, conf
),
558 DEFINE_PROP_STRING("phy_model", MilkymistMinimacState
, phy_model
),
559 DEFINE_PROP_END_OF_LIST(),
563 static void milkymist_minimac_register(void)
565 sysbus_register_withprop(&milkymist_minimac_info
);
568 device_init(milkymist_minimac_register
)