2 * QEMU model of the Milkymist minimac2 block.
4 * Copyright (c) 2011 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:
26 #include "hw/sysbus.h"
29 #include "qemu/error-report.h"
30 #include "hw/qdev-addr.h"
46 SETUP_PHY_RST
= (1<<0),
79 #define MINIMAC2_MTU 1530
80 #define MINIMAC2_BUFFER_SIZE 2048
82 struct MilkymistMinimac2MdioState
{
92 typedef struct MilkymistMinimac2MdioState MilkymistMinimac2MdioState
;
94 struct MilkymistMinimac2State
{
100 MemoryRegion regs_region
;
105 uint32_t regs
[R_MAX
];
107 MilkymistMinimac2MdioState mdio
;
109 uint16_t phy_regs
[R_PHY_MAX
];
115 typedef struct MilkymistMinimac2State MilkymistMinimac2State
;
117 static const uint8_t preamble_sfd
[] = {
118 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xd5
121 static void minimac2_mdio_write_reg(MilkymistMinimac2State
*s
,
122 uint8_t phy_addr
, uint8_t reg_addr
, uint16_t value
)
124 trace_milkymist_minimac2_mdio_write(phy_addr
, reg_addr
, value
);
129 static uint16_t minimac2_mdio_read_reg(MilkymistMinimac2State
*s
,
130 uint8_t phy_addr
, uint8_t reg_addr
)
132 uint16_t r
= s
->phy_regs
[reg_addr
];
134 trace_milkymist_minimac2_mdio_read(phy_addr
, reg_addr
, r
);
139 static void minimac2_update_mdio(MilkymistMinimac2State
*s
)
141 MilkymistMinimac2MdioState
*m
= &s
->mdio
;
143 /* detect rising clk edge */
144 if (m
->last_clk
== 0 && (s
->regs
[R_MDIO
] & MDIO_CLK
)) {
146 int bit
= ((s
->regs
[R_MDIO
] & MDIO_DO
)
147 && (s
->regs
[R_MDIO
] & MDIO_OE
)) ? 1 : 0;
148 m
->data
= (m
->data
<< 1) | bit
;
151 if (m
->data
== 0xffffffff) {
155 if (m
->count
== 16) {
156 uint8_t start
= (m
->data
>> 14) & 0x3;
157 uint8_t op
= (m
->data
>> 12) & 0x3;
158 uint8_t ta
= (m
->data
) & 0x3;
160 if (start
== 1 && op
== MDIO_OP_WRITE
&& ta
== 2) {
161 m
->state
= MDIO_STATE_WRITING
;
162 } else if (start
== 1 && op
== MDIO_OP_READ
&& (ta
& 1) == 0) {
163 m
->state
= MDIO_STATE_READING
;
165 m
->state
= MDIO_STATE_IDLE
;
168 if (m
->state
!= MDIO_STATE_IDLE
) {
169 m
->phy_addr
= (m
->data
>> 7) & 0x1f;
170 m
->reg_addr
= (m
->data
>> 2) & 0x1f;
173 if (m
->state
== MDIO_STATE_READING
) {
174 m
->data_out
= minimac2_mdio_read_reg(s
, m
->phy_addr
,
179 if (m
->count
< 16 && m
->state
== MDIO_STATE_READING
) {
180 int bit
= (m
->data_out
& 0x8000) ? 1 : 0;
184 s
->regs
[R_MDIO
] |= MDIO_DI
;
186 s
->regs
[R_MDIO
] &= ~MDIO_DI
;
190 if (m
->count
== 0 && m
->state
) {
191 if (m
->state
== MDIO_STATE_WRITING
) {
192 uint16_t data
= m
->data
& 0xffff;
193 minimac2_mdio_write_reg(s
, m
->phy_addr
, m
->reg_addr
, data
);
195 m
->state
= MDIO_STATE_IDLE
;
200 m
->last_clk
= (s
->regs
[R_MDIO
] & MDIO_CLK
) ? 1 : 0;
203 static size_t assemble_frame(uint8_t *buf
, size_t size
,
204 const uint8_t *payload
, size_t payload_size
)
208 if (size
< payload_size
+ 12) {
209 error_report("milkymist_minimac2: received too big ethernet frame");
213 /* prepend preamble and sfd */
214 memcpy(buf
, preamble_sfd
, 8);
216 /* now copy the payload */
217 memcpy(buf
+ 8, payload
, payload_size
);
219 /* pad frame if needed */
220 if (payload_size
< 60) {
221 memset(buf
+ payload_size
+ 8, 0, 60 - payload_size
);
226 crc
= cpu_to_le32(crc32(0, buf
+ 8, payload_size
));
227 memcpy(buf
+ payload_size
+ 8, &crc
, 4);
229 return payload_size
+ 12;
232 static void minimac2_tx(MilkymistMinimac2State
*s
)
234 uint32_t txcount
= s
->regs
[R_TXCOUNT
];
235 uint8_t *buf
= s
->tx_buf
;
238 error_report("milkymist_minimac2: ethernet frame too small (%u < %u)",
243 if (txcount
> MINIMAC2_MTU
) {
244 error_report("milkymist_minimac2: MTU exceeded (%u > %u)",
245 txcount
, MINIMAC2_MTU
);
249 if (memcmp(buf
, preamble_sfd
, 8) != 0) {
250 error_report("milkymist_minimac2: frame doesn't contain the preamble "
251 "and/or the SFD (%02x %02x %02x %02x %02x %02x %02x %02x)",
252 buf
[0], buf
[1], buf
[2], buf
[3], buf
[4], buf
[5], buf
[6], buf
[7]);
256 trace_milkymist_minimac2_tx_frame(txcount
- 12);
258 /* send packet, skipping preamble and sfd */
259 qemu_send_packet_raw(qemu_get_queue(s
->nic
), buf
+ 8, txcount
- 12);
261 s
->regs
[R_TXCOUNT
] = 0;
264 trace_milkymist_minimac2_pulse_irq_tx();
265 qemu_irq_pulse(s
->tx_irq
);
268 static void update_rx_interrupt(MilkymistMinimac2State
*s
)
270 if (s
->regs
[R_STATE0
] == STATE_PENDING
271 || s
->regs
[R_STATE1
] == STATE_PENDING
) {
272 trace_milkymist_minimac2_raise_irq_rx();
273 qemu_irq_raise(s
->rx_irq
);
275 trace_milkymist_minimac2_lower_irq_rx();
276 qemu_irq_lower(s
->rx_irq
);
280 static ssize_t
minimac2_rx(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
282 MilkymistMinimac2State
*s
= qemu_get_nic_opaque(nc
);
290 trace_milkymist_minimac2_rx_frame(buf
, size
);
292 /* choose appropriate slot */
293 if (s
->regs
[R_STATE0
] == STATE_LOADED
) {
297 } else if (s
->regs
[R_STATE1
] == STATE_LOADED
) {
302 trace_milkymist_minimac2_drop_rx_frame(buf
);
307 frame_size
= assemble_frame(rx_buf
, MINIMAC2_BUFFER_SIZE
, buf
, size
);
309 if (frame_size
== 0) {
313 trace_milkymist_minimac2_rx_transfer(rx_buf
, frame_size
);
316 s
->regs
[r_count
] = frame_size
;
317 s
->regs
[r_state
] = STATE_PENDING
;
319 update_rx_interrupt(s
);
325 minimac2_read(void *opaque
, hwaddr addr
, unsigned size
)
327 MilkymistMinimac2State
*s
= opaque
;
343 error_report("milkymist_minimac2: read access to unknown register 0x"
344 TARGET_FMT_plx
, addr
<< 2);
348 trace_milkymist_minimac2_memory_read(addr
<< 2, r
);
354 minimac2_write(void *opaque
, hwaddr addr
, uint64_t value
,
357 MilkymistMinimac2State
*s
= opaque
;
359 trace_milkymist_minimac2_memory_read(addr
, value
);
365 /* MDIO_DI is read only */
366 int mdio_di
= (s
->regs
[R_MDIO
] & MDIO_DI
);
367 s
->regs
[R_MDIO
] = value
;
369 s
->regs
[R_MDIO
] |= mdio_di
;
371 s
->regs
[R_MDIO
] &= ~mdio_di
;
374 minimac2_update_mdio(s
);
377 s
->regs
[addr
] = value
;
384 s
->regs
[addr
] = value
;
385 update_rx_interrupt(s
);
390 s
->regs
[addr
] = value
;
394 error_report("milkymist_minimac2: write access to unknown register 0x"
395 TARGET_FMT_plx
, addr
<< 2);
400 static const MemoryRegionOps minimac2_ops
= {
401 .read
= minimac2_read
,
402 .write
= minimac2_write
,
404 .min_access_size
= 4,
405 .max_access_size
= 4,
407 .endianness
= DEVICE_NATIVE_ENDIAN
,
410 static int minimac2_can_rx(NetClientState
*nc
)
412 MilkymistMinimac2State
*s
= qemu_get_nic_opaque(nc
);
414 if (s
->regs
[R_STATE0
] == STATE_LOADED
) {
417 if (s
->regs
[R_STATE1
] == STATE_LOADED
) {
424 static void minimac2_cleanup(NetClientState
*nc
)
426 MilkymistMinimac2State
*s
= qemu_get_nic_opaque(nc
);
431 static void milkymist_minimac2_reset(DeviceState
*d
)
433 MilkymistMinimac2State
*s
=
434 container_of(d
, MilkymistMinimac2State
, busdev
.qdev
);
437 for (i
= 0; i
< R_MAX
; i
++) {
440 for (i
= 0; i
< R_PHY_MAX
; i
++) {
445 s
->phy_regs
[R_PHY_ID1
] = 0x0022; /* Micrel KSZ8001L */
446 s
->phy_regs
[R_PHY_ID2
] = 0x161a;
449 static NetClientInfo net_milkymist_minimac2_info
= {
450 .type
= NET_CLIENT_OPTIONS_KIND_NIC
,
451 .size
= sizeof(NICState
),
452 .can_receive
= minimac2_can_rx
,
453 .receive
= minimac2_rx
,
454 .cleanup
= minimac2_cleanup
,
457 static int milkymist_minimac2_init(SysBusDevice
*dev
)
459 MilkymistMinimac2State
*s
= FROM_SYSBUS(typeof(*s
), dev
);
460 size_t buffers_size
= TARGET_PAGE_ALIGN(3 * MINIMAC2_BUFFER_SIZE
);
462 sysbus_init_irq(dev
, &s
->rx_irq
);
463 sysbus_init_irq(dev
, &s
->tx_irq
);
465 memory_region_init_io(&s
->regs_region
, &minimac2_ops
, s
,
466 "milkymist-minimac2", R_MAX
* 4);
467 sysbus_init_mmio(dev
, &s
->regs_region
);
469 /* register buffers memory */
470 memory_region_init_ram(&s
->buffers
, "milkymist-minimac2.buffers",
472 vmstate_register_ram_global(&s
->buffers
);
473 s
->rx0_buf
= memory_region_get_ram_ptr(&s
->buffers
);
474 s
->rx1_buf
= s
->rx0_buf
+ MINIMAC2_BUFFER_SIZE
;
475 s
->tx_buf
= s
->rx1_buf
+ MINIMAC2_BUFFER_SIZE
;
477 sysbus_init_mmio(dev
, &s
->buffers
);
479 qemu_macaddr_default_if_unset(&s
->conf
.macaddr
);
480 s
->nic
= qemu_new_nic(&net_milkymist_minimac2_info
, &s
->conf
,
481 object_get_typename(OBJECT(dev
)), dev
->qdev
.id
, s
);
482 qemu_format_nic_info_str(qemu_get_queue(s
->nic
), s
->conf
.macaddr
.a
);
487 static const VMStateDescription vmstate_milkymist_minimac2_mdio
= {
488 .name
= "milkymist-minimac2-mdio",
490 .minimum_version_id
= 1,
491 .minimum_version_id_old
= 1,
492 .fields
= (VMStateField
[]) {
493 VMSTATE_INT32(last_clk
, MilkymistMinimac2MdioState
),
494 VMSTATE_INT32(count
, MilkymistMinimac2MdioState
),
495 VMSTATE_UINT32(data
, MilkymistMinimac2MdioState
),
496 VMSTATE_UINT16(data_out
, MilkymistMinimac2MdioState
),
497 VMSTATE_INT32(state
, MilkymistMinimac2MdioState
),
498 VMSTATE_UINT8(phy_addr
, MilkymistMinimac2MdioState
),
499 VMSTATE_UINT8(reg_addr
, MilkymistMinimac2MdioState
),
500 VMSTATE_END_OF_LIST()
504 static const VMStateDescription vmstate_milkymist_minimac2
= {
505 .name
= "milkymist-minimac2",
507 .minimum_version_id
= 1,
508 .minimum_version_id_old
= 1,
509 .fields
= (VMStateField
[]) {
510 VMSTATE_UINT32_ARRAY(regs
, MilkymistMinimac2State
, R_MAX
),
511 VMSTATE_UINT16_ARRAY(phy_regs
, MilkymistMinimac2State
, R_PHY_MAX
),
512 VMSTATE_STRUCT(mdio
, MilkymistMinimac2State
, 0,
513 vmstate_milkymist_minimac2_mdio
, MilkymistMinimac2MdioState
),
514 VMSTATE_END_OF_LIST()
518 static Property milkymist_minimac2_properties
[] = {
519 DEFINE_NIC_PROPERTIES(MilkymistMinimac2State
, conf
),
520 DEFINE_PROP_STRING("phy_model", MilkymistMinimac2State
, phy_model
),
521 DEFINE_PROP_END_OF_LIST(),
524 static void milkymist_minimac2_class_init(ObjectClass
*klass
, void *data
)
526 DeviceClass
*dc
= DEVICE_CLASS(klass
);
527 SysBusDeviceClass
*k
= SYS_BUS_DEVICE_CLASS(klass
);
529 k
->init
= milkymist_minimac2_init
;
530 dc
->reset
= milkymist_minimac2_reset
;
531 dc
->vmsd
= &vmstate_milkymist_minimac2
;
532 dc
->props
= milkymist_minimac2_properties
;
535 static const TypeInfo milkymist_minimac2_info
= {
536 .name
= "milkymist-minimac2",
537 .parent
= TYPE_SYS_BUS_DEVICE
,
538 .instance_size
= sizeof(MilkymistMinimac2State
),
539 .class_init
= milkymist_minimac2_class_init
,
542 static void milkymist_minimac2_register_types(void)
544 type_register_static(&milkymist_minimac2_info
);
547 type_init(milkymist_minimac2_register_types
)