2 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
4 * PAPR Inter-VM Logical Lan, aka ibmveth
6 * Copyright (c) 2010,2011 David Gibson, IBM Corporation.
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and associated documentation files (the "Software"), to deal
10 * in the Software without restriction, including without limitation the rights
11 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 * copies of the Software, and to permit persons to whom the Software is
13 * furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
27 #include "qemu/osdep.h"
28 #include "qemu-common.h"
33 #include "hw/ppc/spapr.h"
34 #include "hw/ppc/spapr_vio.h"
35 #include "sysemu/sysemu.h"
40 #define MAX_PACKET_SIZE 65536
45 #define DPRINTF(fmt...) do { fprintf(stderr, fmt); } while (0)
47 #define DPRINTF(fmt...)
54 typedef uint64_t vlan_bd_t
;
56 #define VLAN_BD_VALID 0x8000000000000000ULL
57 #define VLAN_BD_TOGGLE 0x4000000000000000ULL
58 #define VLAN_BD_NO_CSUM 0x0200000000000000ULL
59 #define VLAN_BD_CSUM_GOOD 0x0100000000000000ULL
60 #define VLAN_BD_LEN_MASK 0x00ffffff00000000ULL
61 #define VLAN_BD_LEN(bd) (((bd) & VLAN_BD_LEN_MASK) >> 32)
62 #define VLAN_BD_ADDR_MASK 0x00000000ffffffffULL
63 #define VLAN_BD_ADDR(bd) ((bd) & VLAN_BD_ADDR_MASK)
65 #define VLAN_VALID_BD(addr, len) (VLAN_BD_VALID | \
66 (((len) << 32) & VLAN_BD_LEN_MASK) | \
67 (addr & VLAN_BD_ADDR_MASK))
69 #define VLAN_RXQC_TOGGLE 0x80
70 #define VLAN_RXQC_VALID 0x40
71 #define VLAN_RXQC_NO_CSUM 0x02
72 #define VLAN_RXQC_CSUM_GOOD 0x01
74 #define VLAN_RQ_ALIGNMENT 16
75 #define VLAN_RXQ_BD_OFF 0
76 #define VLAN_FILTER_BD_OFF 8
77 #define VLAN_RX_BDS_OFF 16
79 * The final 8 bytes of the buffer list is a counter of frames dropped
80 * because there was not a buffer in the buffer list capable of holding
81 * the frame. We must avoid it, or the operating system will report garbage
84 #define VLAN_RX_BDS_LEN (SPAPR_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF - 8)
85 #define VLAN_MAX_BUFS (VLAN_RX_BDS_LEN / 8)
87 #define TYPE_VIO_SPAPR_VLAN_DEVICE "spapr-vlan"
88 #define VIO_SPAPR_VLAN_DEVICE(obj) \
89 OBJECT_CHECK(VIOsPAPRVLANDevice, (obj), TYPE_VIO_SPAPR_VLAN_DEVICE)
91 typedef struct VIOsPAPRVLANDevice
{
96 target_ulong buf_list
;
97 uint32_t add_buf_ptr
, use_buf_ptr
, rx_bufs
;
101 static int spapr_vlan_can_receive(NetClientState
*nc
)
103 VIOsPAPRVLANDevice
*dev
= qemu_get_nic_opaque(nc
);
105 return (dev
->isopen
&& dev
->rx_bufs
> 0);
108 static ssize_t
spapr_vlan_receive(NetClientState
*nc
, const uint8_t *buf
,
111 VIOsPAPRVLANDevice
*dev
= qemu_get_nic_opaque(nc
);
112 VIOsPAPRDevice
*sdev
= VIO_SPAPR_DEVICE(dev
);
113 vlan_bd_t rxq_bd
= vio_ldq(sdev
, dev
->buf_list
+ VLAN_RXQ_BD_OFF
);
115 int buf_ptr
= dev
->use_buf_ptr
;
119 DPRINTF("spapr_vlan_receive() [%s] rx_bufs=%d\n", sdev
->qdev
.id
,
132 if (buf_ptr
>= (VLAN_RX_BDS_LEN
+ VLAN_RX_BDS_OFF
)) {
133 buf_ptr
= VLAN_RX_BDS_OFF
;
136 bd
= vio_ldq(sdev
, dev
->buf_list
+ buf_ptr
);
137 DPRINTF("use_buf_ptr=%d bd=0x%016llx\n",
138 buf_ptr
, (unsigned long long)bd
);
139 } while ((!(bd
& VLAN_BD_VALID
) || (VLAN_BD_LEN(bd
) < (size
+ 8)))
140 && (buf_ptr
!= dev
->use_buf_ptr
));
142 if (!(bd
& VLAN_BD_VALID
) || (VLAN_BD_LEN(bd
) < (size
+ 8))) {
143 /* Failed to find a suitable buffer */
147 /* Remove the buffer from the pool */
149 dev
->use_buf_ptr
= buf_ptr
;
150 vio_stq(sdev
, dev
->buf_list
+ dev
->use_buf_ptr
, 0);
152 DPRINTF("Found buffer: ptr=%d num=%d\n", dev
->use_buf_ptr
, dev
->rx_bufs
);
154 /* Transfer the packet data */
155 if (spapr_vio_dma_write(sdev
, VLAN_BD_ADDR(bd
) + 8, buf
, size
) < 0) {
159 DPRINTF("spapr_vlan_receive: DMA write completed\n");
161 /* Update the receive queue */
162 control
= VLAN_RXQC_TOGGLE
| VLAN_RXQC_VALID
;
163 if (rxq_bd
& VLAN_BD_TOGGLE
) {
164 control
^= VLAN_RXQC_TOGGLE
;
167 handle
= vio_ldq(sdev
, VLAN_BD_ADDR(bd
));
168 vio_stq(sdev
, VLAN_BD_ADDR(rxq_bd
) + dev
->rxq_ptr
+ 8, handle
);
169 vio_stl(sdev
, VLAN_BD_ADDR(rxq_bd
) + dev
->rxq_ptr
+ 4, size
);
170 vio_sth(sdev
, VLAN_BD_ADDR(rxq_bd
) + dev
->rxq_ptr
+ 2, 8);
171 vio_stb(sdev
, VLAN_BD_ADDR(rxq_bd
) + dev
->rxq_ptr
, control
);
173 DPRINTF("wrote rxq entry (ptr=0x%llx): 0x%016llx 0x%016llx\n",
174 (unsigned long long)dev
->rxq_ptr
,
175 (unsigned long long)vio_ldq(sdev
, VLAN_BD_ADDR(rxq_bd
) +
177 (unsigned long long)vio_ldq(sdev
, VLAN_BD_ADDR(rxq_bd
) +
181 if (dev
->rxq_ptr
>= VLAN_BD_LEN(rxq_bd
)) {
183 vio_stq(sdev
, dev
->buf_list
+ VLAN_RXQ_BD_OFF
, rxq_bd
^ VLAN_BD_TOGGLE
);
186 if (sdev
->signal_state
& 1) {
187 qemu_irq_pulse(spapr_vio_qirq(sdev
));
193 static NetClientInfo net_spapr_vlan_info
= {
194 .type
= NET_CLIENT_OPTIONS_KIND_NIC
,
195 .size
= sizeof(NICState
),
196 .can_receive
= spapr_vlan_can_receive
,
197 .receive
= spapr_vlan_receive
,
200 static void spapr_vlan_reset(VIOsPAPRDevice
*sdev
)
202 VIOsPAPRVLANDevice
*dev
= VIO_SPAPR_VLAN_DEVICE(sdev
);
209 static void spapr_vlan_realize(VIOsPAPRDevice
*sdev
, Error
**errp
)
211 VIOsPAPRVLANDevice
*dev
= VIO_SPAPR_VLAN_DEVICE(sdev
);
213 qemu_macaddr_default_if_unset(&dev
->nicconf
.macaddr
);
215 dev
->nic
= qemu_new_nic(&net_spapr_vlan_info
, &dev
->nicconf
,
216 object_get_typename(OBJECT(sdev
)), sdev
->qdev
.id
, dev
);
217 qemu_format_nic_info_str(qemu_get_queue(dev
->nic
), dev
->nicconf
.macaddr
.a
);
220 static void spapr_vlan_instance_init(Object
*obj
)
222 VIOsPAPRVLANDevice
*dev
= VIO_SPAPR_VLAN_DEVICE(obj
);
224 device_add_bootindex_property(obj
, &dev
->nicconf
.bootindex
,
229 void spapr_vlan_create(VIOsPAPRBus
*bus
, NICInfo
*nd
)
233 dev
= qdev_create(&bus
->bus
, "spapr-vlan");
235 qdev_set_nic_properties(dev
, nd
);
237 qdev_init_nofail(dev
);
240 static int spapr_vlan_devnode(VIOsPAPRDevice
*dev
, void *fdt
, int node_off
)
242 VIOsPAPRVLANDevice
*vdev
= VIO_SPAPR_VLAN_DEVICE(dev
);
243 uint8_t padded_mac
[8] = {0, 0};
246 /* Some old phyp versions give the mac address in an 8-byte
247 * property. The kernel driver has an insane workaround for this;
248 * rather than doing the obvious thing and checking the property
249 * length, it checks whether the first byte has 0b10 in the low
250 * bits. If a correct 6-byte property has a different first byte
251 * the kernel will get the wrong mac address, overrunning its
252 * buffer in the process (read only, thank goodness).
254 * Here we workaround the kernel workaround by always supplying an
255 * 8-byte property, with the mac address in the last six bytes */
256 memcpy(&padded_mac
[2], &vdev
->nicconf
.macaddr
, ETH_ALEN
);
257 ret
= fdt_setprop(fdt
, node_off
, "local-mac-address",
258 padded_mac
, sizeof(padded_mac
));
263 ret
= fdt_setprop_cell(fdt
, node_off
, "ibm,mac-address-filters", 0);
271 static int check_bd(VIOsPAPRVLANDevice
*dev
, vlan_bd_t bd
,
272 target_ulong alignment
)
274 if ((VLAN_BD_ADDR(bd
) % alignment
)
275 || (VLAN_BD_LEN(bd
) % alignment
)) {
279 if (!spapr_vio_dma_valid(&dev
->sdev
, VLAN_BD_ADDR(bd
),
280 VLAN_BD_LEN(bd
), DMA_DIRECTION_FROM_DEVICE
)
281 || !spapr_vio_dma_valid(&dev
->sdev
, VLAN_BD_ADDR(bd
),
282 VLAN_BD_LEN(bd
), DMA_DIRECTION_TO_DEVICE
)) {
289 static target_ulong
h_register_logical_lan(PowerPCCPU
*cpu
,
290 sPAPRMachineState
*spapr
,
294 target_ulong reg
= args
[0];
295 target_ulong buf_list
= args
[1];
296 target_ulong rec_queue
= args
[2];
297 target_ulong filter_list
= args
[3];
298 VIOsPAPRDevice
*sdev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
299 VIOsPAPRVLANDevice
*dev
= VIO_SPAPR_VLAN_DEVICE(sdev
);
300 vlan_bd_t filter_list_bd
;
307 hcall_dprintf("H_REGISTER_LOGICAL_LAN called twice without "
308 "H_FREE_LOGICAL_LAN\n");
312 if (check_bd(dev
, VLAN_VALID_BD(buf_list
, SPAPR_TCE_PAGE_SIZE
),
313 SPAPR_TCE_PAGE_SIZE
) < 0) {
314 hcall_dprintf("Bad buf_list 0x" TARGET_FMT_lx
"\n", buf_list
);
318 filter_list_bd
= VLAN_VALID_BD(filter_list
, SPAPR_TCE_PAGE_SIZE
);
319 if (check_bd(dev
, filter_list_bd
, SPAPR_TCE_PAGE_SIZE
) < 0) {
320 hcall_dprintf("Bad filter_list 0x" TARGET_FMT_lx
"\n", filter_list
);
324 if (!(rec_queue
& VLAN_BD_VALID
)
325 || (check_bd(dev
, rec_queue
, VLAN_RQ_ALIGNMENT
) < 0)) {
326 hcall_dprintf("Bad receive queue\n");
330 dev
->buf_list
= buf_list
;
331 sdev
->signal_state
= 0;
333 rec_queue
&= ~VLAN_BD_TOGGLE
;
335 /* Initialize the buffer list */
336 vio_stq(sdev
, buf_list
, rec_queue
);
337 vio_stq(sdev
, buf_list
+ 8, filter_list_bd
);
338 spapr_vio_dma_set(sdev
, buf_list
+ VLAN_RX_BDS_OFF
, 0,
339 SPAPR_TCE_PAGE_SIZE
- VLAN_RX_BDS_OFF
);
340 dev
->add_buf_ptr
= VLAN_RX_BDS_OFF
- 8;
341 dev
->use_buf_ptr
= VLAN_RX_BDS_OFF
- 8;
345 /* Initialize the receive queue */
346 spapr_vio_dma_set(sdev
, VLAN_BD_ADDR(rec_queue
), 0, VLAN_BD_LEN(rec_queue
));
349 qemu_flush_queued_packets(qemu_get_queue(dev
->nic
));
355 static target_ulong
h_free_logical_lan(PowerPCCPU
*cpu
,
356 sPAPRMachineState
*spapr
,
357 target_ulong opcode
, target_ulong
*args
)
359 target_ulong reg
= args
[0];
360 VIOsPAPRDevice
*sdev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
361 VIOsPAPRVLANDevice
*dev
= VIO_SPAPR_VLAN_DEVICE(sdev
);
368 hcall_dprintf("H_FREE_LOGICAL_LAN called without "
369 "H_REGISTER_LOGICAL_LAN\n");
373 spapr_vlan_reset(sdev
);
377 static target_ulong
h_add_logical_lan_buffer(PowerPCCPU
*cpu
,
378 sPAPRMachineState
*spapr
,
382 target_ulong reg
= args
[0];
383 target_ulong buf
= args
[1];
384 VIOsPAPRDevice
*sdev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
385 VIOsPAPRVLANDevice
*dev
= VIO_SPAPR_VLAN_DEVICE(sdev
);
388 DPRINTF("H_ADD_LOGICAL_LAN_BUFFER(0x" TARGET_FMT_lx
389 ", 0x" TARGET_FMT_lx
")\n", reg
, buf
);
392 hcall_dprintf("Bad device\n");
396 if ((check_bd(dev
, buf
, 4) < 0)
397 || (VLAN_BD_LEN(buf
) < 16)) {
398 hcall_dprintf("Bad buffer enqueued\n");
402 if (!dev
->isopen
|| dev
->rx_bufs
>= VLAN_MAX_BUFS
) {
407 dev
->add_buf_ptr
+= 8;
408 if (dev
->add_buf_ptr
>= (VLAN_RX_BDS_LEN
+ VLAN_RX_BDS_OFF
)) {
409 dev
->add_buf_ptr
= VLAN_RX_BDS_OFF
;
412 bd
= vio_ldq(sdev
, dev
->buf_list
+ dev
->add_buf_ptr
);
413 } while (bd
& VLAN_BD_VALID
);
415 vio_stq(sdev
, dev
->buf_list
+ dev
->add_buf_ptr
, buf
);
419 qemu_flush_queued_packets(qemu_get_queue(dev
->nic
));
421 DPRINTF("h_add_logical_lan_buffer(): Added buf ptr=%d rx_bufs=%d"
422 " bd=0x%016llx\n", dev
->add_buf_ptr
, dev
->rx_bufs
,
423 (unsigned long long)buf
);
428 static target_ulong
h_send_logical_lan(PowerPCCPU
*cpu
,
429 sPAPRMachineState
*spapr
,
430 target_ulong opcode
, target_ulong
*args
)
432 target_ulong reg
= args
[0];
433 target_ulong
*bufs
= args
+ 1;
434 target_ulong continue_token
= args
[7];
435 VIOsPAPRDevice
*sdev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
436 VIOsPAPRVLANDevice
*dev
= VIO_SPAPR_VLAN_DEVICE(sdev
);
442 DPRINTF("H_SEND_LOGICAL_LAN(0x" TARGET_FMT_lx
", <bufs>, 0x"
443 TARGET_FMT_lx
")\n", reg
, continue_token
);
449 DPRINTF("rxbufs = %d\n", dev
->rx_bufs
);
455 if (continue_token
) {
456 return H_HARDWARE
; /* FIXME actually handle this */
460 for (i
= 0; i
< 6; i
++) {
461 DPRINTF(" buf desc: 0x" TARGET_FMT_lx
"\n", bufs
[i
]);
462 if (!(bufs
[i
] & VLAN_BD_VALID
)) {
465 total_len
+= VLAN_BD_LEN(bufs
[i
]);
469 DPRINTF("h_send_logical_lan() %d buffers, total length 0x%x\n",
472 if (total_len
== 0) {
476 if (total_len
> MAX_PACKET_SIZE
) {
477 /* Don't let the guest force too large an allocation */
481 lbuf
= alloca(total_len
);
483 for (i
= 0; i
< nbufs
; i
++) {
484 ret
= spapr_vio_dma_read(sdev
, VLAN_BD_ADDR(bufs
[i
]),
485 p
, VLAN_BD_LEN(bufs
[i
]));
490 p
+= VLAN_BD_LEN(bufs
[i
]);
493 qemu_send_packet(qemu_get_queue(dev
->nic
), lbuf
, total_len
);
498 static target_ulong
h_multicast_ctrl(PowerPCCPU
*cpu
, sPAPRMachineState
*spapr
,
499 target_ulong opcode
, target_ulong
*args
)
501 target_ulong reg
= args
[0];
502 VIOsPAPRDevice
*dev
= spapr_vio_find_by_reg(spapr
->vio_bus
, reg
);
511 static Property spapr_vlan_properties
[] = {
512 DEFINE_SPAPR_PROPERTIES(VIOsPAPRVLANDevice
, sdev
),
513 DEFINE_NIC_PROPERTIES(VIOsPAPRVLANDevice
, nicconf
),
514 DEFINE_PROP_END_OF_LIST(),
517 static const VMStateDescription vmstate_spapr_llan
= {
518 .name
= "spapr_llan",
520 .minimum_version_id
= 1,
521 .fields
= (VMStateField
[]) {
522 VMSTATE_SPAPR_VIO(sdev
, VIOsPAPRVLANDevice
),
524 VMSTATE_BOOL(isopen
, VIOsPAPRVLANDevice
),
525 VMSTATE_UINTTL(buf_list
, VIOsPAPRVLANDevice
),
526 VMSTATE_UINT32(add_buf_ptr
, VIOsPAPRVLANDevice
),
527 VMSTATE_UINT32(use_buf_ptr
, VIOsPAPRVLANDevice
),
528 VMSTATE_UINT32(rx_bufs
, VIOsPAPRVLANDevice
),
529 VMSTATE_UINTTL(rxq_ptr
, VIOsPAPRVLANDevice
),
531 VMSTATE_END_OF_LIST()
535 static void spapr_vlan_class_init(ObjectClass
*klass
, void *data
)
537 DeviceClass
*dc
= DEVICE_CLASS(klass
);
538 VIOsPAPRDeviceClass
*k
= VIO_SPAPR_DEVICE_CLASS(klass
);
540 k
->realize
= spapr_vlan_realize
;
541 k
->reset
= spapr_vlan_reset
;
542 k
->devnode
= spapr_vlan_devnode
;
543 k
->dt_name
= "l-lan";
544 k
->dt_type
= "network";
545 k
->dt_compatible
= "IBM,l-lan";
546 k
->signal_mask
= 0x1;
547 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
548 dc
->props
= spapr_vlan_properties
;
549 k
->rtce_window_size
= 0x10000000;
550 dc
->vmsd
= &vmstate_spapr_llan
;
553 static const TypeInfo spapr_vlan_info
= {
554 .name
= TYPE_VIO_SPAPR_VLAN_DEVICE
,
555 .parent
= TYPE_VIO_SPAPR_DEVICE
,
556 .instance_size
= sizeof(VIOsPAPRVLANDevice
),
557 .class_init
= spapr_vlan_class_init
,
558 .instance_init
= spapr_vlan_instance_init
,
561 static void spapr_vlan_register_types(void)
563 spapr_register_hypercall(H_REGISTER_LOGICAL_LAN
, h_register_logical_lan
);
564 spapr_register_hypercall(H_FREE_LOGICAL_LAN
, h_free_logical_lan
);
565 spapr_register_hypercall(H_SEND_LOGICAL_LAN
, h_send_logical_lan
);
566 spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER
,
567 h_add_logical_lan_buffer
);
568 spapr_register_hypercall(H_MULTICAST_CTRL
, h_multicast_ctrl
);
569 type_register_static(&spapr_vlan_info
);
572 type_init(spapr_vlan_register_types
)