1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include "qemu/osdep.h"
29#include "cpu.h"
30#include "hw/hw.h"
31#include "qemu/log.h"
32#include "qemu/module.h"
33#include "net/net.h"
34#include "hw/qdev.h"
35#include "hw/ppc/spapr.h"
36#include "hw/ppc/spapr_vio.h"
37#include "sysemu/sysemu.h"
38#include "trace.h"
39
40#include <libfdt.h>
41
42#define ETH_ALEN 6
43#define MAX_PACKET_SIZE 65536
44
45
46#define SPAPRVLAN_FLAG_RX_BUF_POOLS_BIT 0
47#define SPAPRVLAN_FLAG_RX_BUF_POOLS (1 << SPAPRVLAN_FLAG_RX_BUF_POOLS_BIT)
48
49
50
51
52
53typedef uint64_t vlan_bd_t;
54
55#define VLAN_BD_VALID 0x8000000000000000ULL
56#define VLAN_BD_TOGGLE 0x4000000000000000ULL
57#define VLAN_BD_NO_CSUM 0x0200000000000000ULL
58#define VLAN_BD_CSUM_GOOD 0x0100000000000000ULL
59#define VLAN_BD_LEN_MASK 0x00ffffff00000000ULL
60#define VLAN_BD_LEN(bd) (((bd) & VLAN_BD_LEN_MASK) >> 32)
61#define VLAN_BD_ADDR_MASK 0x00000000ffffffffULL
62#define VLAN_BD_ADDR(bd) ((bd) & VLAN_BD_ADDR_MASK)
63
64#define VLAN_VALID_BD(addr, len) (VLAN_BD_VALID | \
65 (((len) << 32) & VLAN_BD_LEN_MASK) | \
66 (addr & VLAN_BD_ADDR_MASK))
67
68#define VLAN_RXQC_TOGGLE 0x80
69#define VLAN_RXQC_VALID 0x40
70#define VLAN_RXQC_NO_CSUM 0x02
71#define VLAN_RXQC_CSUM_GOOD 0x01
72
73#define VLAN_RQ_ALIGNMENT 16
74#define VLAN_RXQ_BD_OFF 0
75#define VLAN_FILTER_BD_OFF 8
76#define VLAN_RX_BDS_OFF 16
77
78
79
80
81
82
83#define VLAN_RX_BDS_LEN (SPAPR_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF - 8)
84#define VLAN_MAX_BUFS (VLAN_RX_BDS_LEN / 8)
85
86#define TYPE_VIO_SPAPR_VLAN_DEVICE "spapr-vlan"
87#define VIO_SPAPR_VLAN_DEVICE(obj) \
88 OBJECT_CHECK(SpaprVioVlan, (obj), TYPE_VIO_SPAPR_VLAN_DEVICE)
89
90#define RX_POOL_MAX_BDS 4096
91#define RX_MAX_POOLS 5
92
93typedef struct {
94 int32_t bufsize;
95 int32_t count;
96 vlan_bd_t bds[RX_POOL_MAX_BDS];
97} RxBufPool;
98
99typedef struct SpaprVioVlan {
100 SpaprVioDevice sdev;
101 NICConf nicconf;
102 NICState *nic;
103 MACAddr perm_mac;
104 bool isopen;
105 hwaddr buf_list;
106 uint32_t add_buf_ptr, use_buf_ptr, rx_bufs;
107 hwaddr rxq_ptr;
108 QEMUTimer *rxp_timer;
109 uint32_t compat_flags;
110 RxBufPool *rx_pool[RX_MAX_POOLS];
111} SpaprVioVlan;
112
113static int spapr_vlan_can_receive(NetClientState *nc)
114{
115 SpaprVioVlan *dev = qemu_get_nic_opaque(nc);
116
117 return (dev->isopen && dev->rx_bufs > 0);
118}
119
120
121
122
123
124
125
126
127static void spapr_vlan_record_dropped_rx_frame(SpaprVioVlan *dev)
128{
129 uint64_t cnt;
130
131 cnt = vio_ldq(&dev->sdev, dev->buf_list + 4096 - 8);
132 vio_stq(&dev->sdev, dev->buf_list + 4096 - 8, cnt + 1);
133}
134
135
136
137
138static vlan_bd_t spapr_vlan_get_rx_bd_from_pool(SpaprVioVlan *dev,
139 size_t size)
140{
141 vlan_bd_t bd;
142 int pool;
143
144 for (pool = 0; pool < RX_MAX_POOLS; pool++) {
145 if (dev->rx_pool[pool]->count > 0 &&
146 dev->rx_pool[pool]->bufsize >= size + 8) {
147 break;
148 }
149 }
150 if (pool == RX_MAX_POOLS) {
151
152 return 0;
153 }
154
155
156 trace_spapr_vlan_get_rx_bd_from_pool_found(pool,
157 dev->rx_pool[pool]->count,
158 dev->rx_bufs);
159
160
161 dev->rx_pool[pool]->count--;
162 bd = dev->rx_pool[pool]->bds[dev->rx_pool[pool]->count];
163 dev->rx_pool[pool]->bds[dev->rx_pool[pool]->count] = 0;
164
165 return bd;
166}
167
168
169
170
171
172static vlan_bd_t spapr_vlan_get_rx_bd_from_page(SpaprVioVlan *dev,
173 size_t size)
174{
175 int buf_ptr = dev->use_buf_ptr;
176 vlan_bd_t bd;
177
178 do {
179 buf_ptr += 8;
180 if (buf_ptr >= VLAN_RX_BDS_LEN + VLAN_RX_BDS_OFF) {
181 buf_ptr = VLAN_RX_BDS_OFF;
182 }
183
184 bd = vio_ldq(&dev->sdev, dev->buf_list + buf_ptr);
185
186 trace_spapr_vlan_get_rx_bd_from_page(buf_ptr, (uint64_t)bd);
187 } while ((!(bd & VLAN_BD_VALID) || VLAN_BD_LEN(bd) < size + 8)
188 && buf_ptr != dev->use_buf_ptr);
189
190 if (!(bd & VLAN_BD_VALID) || VLAN_BD_LEN(bd) < size + 8) {
191
192 return 0;
193 }
194
195
196 dev->use_buf_ptr = buf_ptr;
197 vio_stq(&dev->sdev, dev->buf_list + dev->use_buf_ptr, 0);
198
199 trace_spapr_vlan_get_rx_bd_from_page_found(dev->use_buf_ptr, dev->rx_bufs);
200
201 return bd;
202}
203
204static ssize_t spapr_vlan_receive(NetClientState *nc, const uint8_t *buf,
205 size_t size)
206{
207 SpaprVioVlan *dev = qemu_get_nic_opaque(nc);
208 SpaprVioDevice *sdev = VIO_SPAPR_DEVICE(dev);
209 vlan_bd_t rxq_bd = vio_ldq(sdev, dev->buf_list + VLAN_RXQ_BD_OFF);
210 vlan_bd_t bd;
211 uint64_t handle;
212 uint8_t control;
213
214 trace_spapr_vlan_receive(sdev->qdev.id, dev->rx_bufs);
215
216 if (!dev->isopen) {
217 return -1;
218 }
219
220 if (!dev->rx_bufs) {
221 spapr_vlan_record_dropped_rx_frame(dev);
222 return 0;
223 }
224
225 if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
226 bd = spapr_vlan_get_rx_bd_from_pool(dev, size);
227 } else {
228 bd = spapr_vlan_get_rx_bd_from_page(dev, size);
229 }
230 if (!bd) {
231 spapr_vlan_record_dropped_rx_frame(dev);
232 return 0;
233 }
234
235 dev->rx_bufs--;
236
237
238 if (spapr_vio_dma_write(sdev, VLAN_BD_ADDR(bd) + 8, buf, size) < 0) {
239 return -1;
240 }
241
242 trace_spapr_vlan_receive_dma_completed();
243
244
245 control = VLAN_RXQC_TOGGLE | VLAN_RXQC_VALID;
246 if (rxq_bd & VLAN_BD_TOGGLE) {
247 control ^= VLAN_RXQC_TOGGLE;
248 }
249
250 handle = vio_ldq(sdev, VLAN_BD_ADDR(bd));
251 vio_stq(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 8, handle);
252 vio_stl(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 4, size);
253 vio_sth(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 2, 8);
254 vio_stb(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr, control);
255
256 trace_spapr_vlan_receive_wrote(dev->rxq_ptr,
257 vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) +
258 dev->rxq_ptr),
259 vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) +
260 dev->rxq_ptr + 8));
261
262 dev->rxq_ptr += 16;
263 if (dev->rxq_ptr >= VLAN_BD_LEN(rxq_bd)) {
264 dev->rxq_ptr = 0;
265 vio_stq(sdev, dev->buf_list + VLAN_RXQ_BD_OFF, rxq_bd ^ VLAN_BD_TOGGLE);
266 }
267
268 if (sdev->signal_state & 1) {
269 qemu_irq_pulse(spapr_vio_qirq(sdev));
270 }
271
272 return size;
273}
274
275static NetClientInfo net_spapr_vlan_info = {
276 .type = NET_CLIENT_DRIVER_NIC,
277 .size = sizeof(NICState),
278 .can_receive = spapr_vlan_can_receive,
279 .receive = spapr_vlan_receive,
280};
281
282static void spapr_vlan_flush_rx_queue(void *opaque)
283{
284 SpaprVioVlan *dev = opaque;
285
286 qemu_flush_queued_packets(qemu_get_queue(dev->nic));
287}
288
289static void spapr_vlan_reset_rx_pool(RxBufPool *rxp)
290{
291
292
293
294
295 rxp->bufsize = INT_MAX;
296 rxp->count = 0;
297 memset(rxp->bds, 0, sizeof(rxp->bds));
298}
299
300static void spapr_vlan_reset(SpaprVioDevice *sdev)
301{
302 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
303 int i;
304
305 dev->buf_list = 0;
306 dev->rx_bufs = 0;
307 dev->isopen = 0;
308
309 if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
310 for (i = 0; i < RX_MAX_POOLS; i++) {
311 spapr_vlan_reset_rx_pool(dev->rx_pool[i]);
312 }
313 }
314
315 memcpy(&dev->nicconf.macaddr.a, &dev->perm_mac.a,
316 sizeof(dev->nicconf.macaddr.a));
317 qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
318}
319
320static void spapr_vlan_realize(SpaprVioDevice *sdev, Error **errp)
321{
322 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
323
324 qemu_macaddr_default_if_unset(&dev->nicconf.macaddr);
325
326 memcpy(&dev->perm_mac.a, &dev->nicconf.macaddr.a, sizeof(dev->perm_mac.a));
327
328 dev->nic = qemu_new_nic(&net_spapr_vlan_info, &dev->nicconf,
329 object_get_typename(OBJECT(sdev)), sdev->qdev.id, dev);
330 qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
331
332 dev->rxp_timer = timer_new_us(QEMU_CLOCK_VIRTUAL, spapr_vlan_flush_rx_queue,
333 dev);
334}
335
336static void spapr_vlan_instance_init(Object *obj)
337{
338 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(obj);
339 int i;
340
341 device_add_bootindex_property(obj, &dev->nicconf.bootindex,
342 "bootindex", "",
343 DEVICE(dev), NULL);
344
345 if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
346 for (i = 0; i < RX_MAX_POOLS; i++) {
347 dev->rx_pool[i] = g_new(RxBufPool, 1);
348 spapr_vlan_reset_rx_pool(dev->rx_pool[i]);
349 }
350 }
351}
352
353static void spapr_vlan_instance_finalize(Object *obj)
354{
355 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(obj);
356 int i;
357
358 if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
359 for (i = 0; i < RX_MAX_POOLS; i++) {
360 g_free(dev->rx_pool[i]);
361 dev->rx_pool[i] = NULL;
362 }
363 }
364
365 if (dev->rxp_timer) {
366 timer_del(dev->rxp_timer);
367 timer_free(dev->rxp_timer);
368 }
369}
370
371void spapr_vlan_create(SpaprVioBus *bus, NICInfo *nd)
372{
373 DeviceState *dev;
374
375 dev = qdev_create(&bus->bus, "spapr-vlan");
376
377 qdev_set_nic_properties(dev, nd);
378
379 qdev_init_nofail(dev);
380}
381
382static int spapr_vlan_devnode(SpaprVioDevice *dev, void *fdt, int node_off)
383{
384 SpaprVioVlan *vdev = VIO_SPAPR_VLAN_DEVICE(dev);
385 uint8_t padded_mac[8] = {0, 0};
386 int ret;
387
388
389
390
391
392
393
394
395
396
397
398
399 if ((vdev->nicconf.macaddr.a[0] & 0x3) == 0x2) {
400 ret = fdt_setprop(fdt, node_off, "local-mac-address",
401 &vdev->nicconf.macaddr, ETH_ALEN);
402 } else {
403 memcpy(&padded_mac[2], &vdev->nicconf.macaddr, ETH_ALEN);
404 ret = fdt_setprop(fdt, node_off, "local-mac-address",
405 padded_mac, sizeof(padded_mac));
406 }
407 if (ret < 0) {
408 return ret;
409 }
410
411 ret = fdt_setprop_cell(fdt, node_off, "ibm,mac-address-filters", 0);
412 if (ret < 0) {
413 return ret;
414 }
415
416 return 0;
417}
418
419static int check_bd(SpaprVioVlan *dev, vlan_bd_t bd,
420 target_ulong alignment)
421{
422 if ((VLAN_BD_ADDR(bd) % alignment)
423 || (VLAN_BD_LEN(bd) % alignment)) {
424 return -1;
425 }
426
427 if (!spapr_vio_dma_valid(&dev->sdev, VLAN_BD_ADDR(bd),
428 VLAN_BD_LEN(bd), DMA_DIRECTION_FROM_DEVICE)
429 || !spapr_vio_dma_valid(&dev->sdev, VLAN_BD_ADDR(bd),
430 VLAN_BD_LEN(bd), DMA_DIRECTION_TO_DEVICE)) {
431 return -1;
432 }
433
434 return 0;
435}
436
437static target_ulong h_register_logical_lan(PowerPCCPU *cpu,
438 SpaprMachineState *spapr,
439 target_ulong opcode,
440 target_ulong *args)
441{
442 target_ulong reg = args[0];
443 target_ulong buf_list = args[1];
444 target_ulong rec_queue = args[2];
445 target_ulong filter_list = args[3];
446 SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
447 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
448 vlan_bd_t filter_list_bd;
449
450 if (!dev) {
451 return H_PARAMETER;
452 }
453
454 if (dev->isopen) {
455 hcall_dprintf("H_REGISTER_LOGICAL_LAN called twice without "
456 "H_FREE_LOGICAL_LAN\n");
457 return H_RESOURCE;
458 }
459
460 if (check_bd(dev, VLAN_VALID_BD(buf_list, SPAPR_TCE_PAGE_SIZE),
461 SPAPR_TCE_PAGE_SIZE) < 0) {
462 hcall_dprintf("Bad buf_list 0x" TARGET_FMT_lx "\n", buf_list);
463 return H_PARAMETER;
464 }
465
466 filter_list_bd = VLAN_VALID_BD(filter_list, SPAPR_TCE_PAGE_SIZE);
467 if (check_bd(dev, filter_list_bd, SPAPR_TCE_PAGE_SIZE) < 0) {
468 hcall_dprintf("Bad filter_list 0x" TARGET_FMT_lx "\n", filter_list);
469 return H_PARAMETER;
470 }
471
472 if (!(rec_queue & VLAN_BD_VALID)
473 || (check_bd(dev, rec_queue, VLAN_RQ_ALIGNMENT) < 0)) {
474 hcall_dprintf("Bad receive queue\n");
475 return H_PARAMETER;
476 }
477
478 dev->buf_list = buf_list;
479 sdev->signal_state = 0;
480
481 rec_queue &= ~VLAN_BD_TOGGLE;
482
483
484 vio_stq(sdev, buf_list, rec_queue);
485 vio_stq(sdev, buf_list + 8, filter_list_bd);
486 spapr_vio_dma_set(sdev, buf_list + VLAN_RX_BDS_OFF, 0,
487 SPAPR_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF);
488 dev->add_buf_ptr = VLAN_RX_BDS_OFF - 8;
489 dev->use_buf_ptr = VLAN_RX_BDS_OFF - 8;
490 dev->rx_bufs = 0;
491 dev->rxq_ptr = 0;
492
493
494 spapr_vio_dma_set(sdev, VLAN_BD_ADDR(rec_queue), 0, VLAN_BD_LEN(rec_queue));
495
496 dev->isopen = 1;
497 qemu_flush_queued_packets(qemu_get_queue(dev->nic));
498
499 return H_SUCCESS;
500}
501
502
503static target_ulong h_free_logical_lan(PowerPCCPU *cpu,
504 SpaprMachineState *spapr,
505 target_ulong opcode, target_ulong *args)
506{
507 target_ulong reg = args[0];
508 SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
509 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
510
511 if (!dev) {
512 return H_PARAMETER;
513 }
514
515 if (!dev->isopen) {
516 hcall_dprintf("H_FREE_LOGICAL_LAN called without "
517 "H_REGISTER_LOGICAL_LAN\n");
518 return H_RESOURCE;
519 }
520
521 spapr_vlan_reset(sdev);
522 return H_SUCCESS;
523}
524
525
526
527
528static int rx_pool_size_compare(const void *p1, const void *p2)
529{
530 const RxBufPool *pool1 = *(RxBufPool **)p1;
531 const RxBufPool *pool2 = *(RxBufPool **)p2;
532
533 if (pool1->bufsize < pool2->bufsize) {
534 return -1;
535 }
536 return pool1->bufsize > pool2->bufsize;
537}
538
539
540
541
542
543static int spapr_vlan_get_rx_pool_id(SpaprVioVlan *dev, int size)
544{
545 int pool;
546
547 for (pool = 0; pool < RX_MAX_POOLS; pool++) {
548 if (dev->rx_pool[pool]->bufsize == size) {
549 return pool;
550 }
551 }
552
553 return -1;
554}
555
556
557
558
559static target_long spapr_vlan_add_rxbuf_to_pool(SpaprVioVlan *dev,
560 target_ulong buf)
561{
562 int size = VLAN_BD_LEN(buf);
563 int pool;
564
565 pool = spapr_vlan_get_rx_pool_id(dev, size);
566 if (pool < 0) {
567
568
569
570
571
572
573 for (pool = RX_MAX_POOLS - 1; pool >= 0 ; pool--) {
574 if (dev->rx_pool[pool]->count == 0) {
575 dev->rx_pool[pool]->bufsize = size;
576
577
578
579
580 qsort(dev->rx_pool, RX_MAX_POOLS, sizeof(dev->rx_pool[0]),
581 rx_pool_size_compare);
582 pool = spapr_vlan_get_rx_pool_id(dev, size);
583 trace_spapr_vlan_add_rxbuf_to_pool_create(pool,
584 VLAN_BD_LEN(buf));
585 break;
586 }
587 }
588 }
589
590 if (pool < 0 || dev->rx_pool[pool]->count >= RX_POOL_MAX_BDS) {
591 return H_RESOURCE;
592 }
593
594 trace_spapr_vlan_add_rxbuf_to_pool(pool, VLAN_BD_LEN(buf),
595 dev->rx_pool[pool]->count);
596
597 dev->rx_pool[pool]->bds[dev->rx_pool[pool]->count++] = buf;
598
599 return 0;
600}
601
602
603
604
605
606static target_long spapr_vlan_add_rxbuf_to_page(SpaprVioVlan *dev,
607 target_ulong buf)
608{
609 vlan_bd_t bd;
610
611 if (dev->rx_bufs >= VLAN_MAX_BUFS) {
612 return H_RESOURCE;
613 }
614
615 do {
616 dev->add_buf_ptr += 8;
617 if (dev->add_buf_ptr >= VLAN_RX_BDS_LEN + VLAN_RX_BDS_OFF) {
618 dev->add_buf_ptr = VLAN_RX_BDS_OFF;
619 }
620
621 bd = vio_ldq(&dev->sdev, dev->buf_list + dev->add_buf_ptr);
622 } while (bd & VLAN_BD_VALID);
623
624 vio_stq(&dev->sdev, dev->buf_list + dev->add_buf_ptr, buf);
625
626 trace_spapr_vlan_add_rxbuf_to_page(dev->add_buf_ptr, dev->rx_bufs, buf);
627
628 return 0;
629}
630
631static target_ulong h_add_logical_lan_buffer(PowerPCCPU *cpu,
632 SpaprMachineState *spapr,
633 target_ulong opcode,
634 target_ulong *args)
635{
636 target_ulong reg = args[0];
637 target_ulong buf = args[1];
638 SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
639 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
640 target_long ret;
641
642 trace_spapr_vlan_h_add_logical_lan_buffer(reg, buf);
643
644 if (!sdev) {
645 hcall_dprintf("Bad device\n");
646 return H_PARAMETER;
647 }
648
649 if ((check_bd(dev, buf, 4) < 0)
650 || (VLAN_BD_LEN(buf) < 16)) {
651 hcall_dprintf("Bad buffer enqueued\n");
652 return H_PARAMETER;
653 }
654
655 if (!dev->isopen) {
656 return H_RESOURCE;
657 }
658
659 if (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) {
660 ret = spapr_vlan_add_rxbuf_to_pool(dev, buf);
661 } else {
662 ret = spapr_vlan_add_rxbuf_to_page(dev, buf);
663 }
664 if (ret) {
665 return ret;
666 }
667
668 dev->rx_bufs++;
669
670
671
672
673
674
675
676 timer_mod(dev->rxp_timer, qemu_clock_get_us(QEMU_CLOCK_VIRTUAL) + 500);
677
678 return H_SUCCESS;
679}
680
681static target_ulong h_send_logical_lan(PowerPCCPU *cpu,
682 SpaprMachineState *spapr,
683 target_ulong opcode, target_ulong *args)
684{
685 target_ulong reg = args[0];
686 target_ulong *bufs = args + 1;
687 target_ulong continue_token = args[7];
688 SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
689 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
690 unsigned total_len;
691 uint8_t *lbuf, *p;
692 int i, nbufs;
693 int ret;
694
695 trace_spapr_vlan_h_send_logical_lan(reg, continue_token);
696
697 if (!sdev) {
698 return H_PARAMETER;
699 }
700
701 trace_spapr_vlan_h_send_logical_lan_rxbufs(dev->rx_bufs);
702
703 if (!dev->isopen) {
704 return H_DROPPED;
705 }
706
707 if (continue_token) {
708 return H_HARDWARE;
709 }
710
711 total_len = 0;
712 for (i = 0; i < 6; i++) {
713 trace_spapr_vlan_h_send_logical_lan_buf_desc(bufs[i]);
714 if (!(bufs[i] & VLAN_BD_VALID)) {
715 break;
716 }
717 total_len += VLAN_BD_LEN(bufs[i]);
718 }
719
720 nbufs = i;
721 trace_spapr_vlan_h_send_logical_lan_total(nbufs, total_len);
722
723 if (total_len == 0) {
724 return H_SUCCESS;
725 }
726
727 if (total_len > MAX_PACKET_SIZE) {
728
729 return H_RESOURCE;
730 }
731
732 lbuf = alloca(total_len);
733 p = lbuf;
734 for (i = 0; i < nbufs; i++) {
735 ret = spapr_vio_dma_read(sdev, VLAN_BD_ADDR(bufs[i]),
736 p, VLAN_BD_LEN(bufs[i]));
737 if (ret < 0) {
738 return ret;
739 }
740
741 p += VLAN_BD_LEN(bufs[i]);
742 }
743
744 qemu_send_packet(qemu_get_queue(dev->nic), lbuf, total_len);
745
746 return H_SUCCESS;
747}
748
749static target_ulong h_multicast_ctrl(PowerPCCPU *cpu, SpaprMachineState *spapr,
750 target_ulong opcode, target_ulong *args)
751{
752 target_ulong reg = args[0];
753 SpaprVioDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
754
755 if (!dev) {
756 return H_PARAMETER;
757 }
758
759 return H_SUCCESS;
760}
761
762static target_ulong h_change_logical_lan_mac(PowerPCCPU *cpu,
763 SpaprMachineState *spapr,
764 target_ulong opcode,
765 target_ulong *args)
766{
767 target_ulong reg = args[0];
768 target_ulong macaddr = args[1];
769 SpaprVioDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
770 SpaprVioVlan *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
771 int i;
772
773 for (i = 0; i < ETH_ALEN; i++) {
774 dev->nicconf.macaddr.a[ETH_ALEN - i - 1] = macaddr & 0xff;
775 macaddr >>= 8;
776 }
777
778 qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
779
780 return H_SUCCESS;
781}
782
783static Property spapr_vlan_properties[] = {
784 DEFINE_SPAPR_PROPERTIES(SpaprVioVlan, sdev),
785 DEFINE_NIC_PROPERTIES(SpaprVioVlan, nicconf),
786 DEFINE_PROP_BIT("use-rx-buffer-pools", SpaprVioVlan,
787 compat_flags, SPAPRVLAN_FLAG_RX_BUF_POOLS_BIT, true),
788 DEFINE_PROP_END_OF_LIST(),
789};
790
791static bool spapr_vlan_rx_buffer_pools_needed(void *opaque)
792{
793 SpaprVioVlan *dev = opaque;
794
795 return (dev->compat_flags & SPAPRVLAN_FLAG_RX_BUF_POOLS) != 0;
796}
797
798static const VMStateDescription vmstate_rx_buffer_pool = {
799 .name = "spapr_llan/rx_buffer_pool",
800 .version_id = 1,
801 .minimum_version_id = 1,
802 .needed = spapr_vlan_rx_buffer_pools_needed,
803 .fields = (VMStateField[]) {
804 VMSTATE_INT32(bufsize, RxBufPool),
805 VMSTATE_INT32(count, RxBufPool),
806 VMSTATE_UINT64_ARRAY(bds, RxBufPool, RX_POOL_MAX_BDS),
807 VMSTATE_END_OF_LIST()
808 }
809};
810
811static const VMStateDescription vmstate_rx_pools = {
812 .name = "spapr_llan/rx_pools",
813 .version_id = 1,
814 .minimum_version_id = 1,
815 .needed = spapr_vlan_rx_buffer_pools_needed,
816 .fields = (VMStateField[]) {
817 VMSTATE_ARRAY_OF_POINTER_TO_STRUCT(rx_pool, SpaprVioVlan,
818 RX_MAX_POOLS, 1,
819 vmstate_rx_buffer_pool, RxBufPool),
820 VMSTATE_END_OF_LIST()
821 }
822};
823
824static const VMStateDescription vmstate_spapr_llan = {
825 .name = "spapr_llan",
826 .version_id = 1,
827 .minimum_version_id = 1,
828 .fields = (VMStateField[]) {
829 VMSTATE_SPAPR_VIO(sdev, SpaprVioVlan),
830
831 VMSTATE_BOOL(isopen, SpaprVioVlan),
832 VMSTATE_UINT64(buf_list, SpaprVioVlan),
833 VMSTATE_UINT32(add_buf_ptr, SpaprVioVlan),
834 VMSTATE_UINT32(use_buf_ptr, SpaprVioVlan),
835 VMSTATE_UINT32(rx_bufs, SpaprVioVlan),
836 VMSTATE_UINT64(rxq_ptr, SpaprVioVlan),
837
838 VMSTATE_END_OF_LIST()
839 },
840 .subsections = (const VMStateDescription * []) {
841 &vmstate_rx_pools,
842 NULL
843 }
844};
845
846static void spapr_vlan_class_init(ObjectClass *klass, void *data)
847{
848 DeviceClass *dc = DEVICE_CLASS(klass);
849 SpaprVioDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass);
850
851 k->realize = spapr_vlan_realize;
852 k->reset = spapr_vlan_reset;
853 k->devnode = spapr_vlan_devnode;
854 k->dt_name = "l-lan";
855 k->dt_type = "network";
856 k->dt_compatible = "IBM,l-lan";
857 k->signal_mask = 0x1;
858 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
859 dc->props = spapr_vlan_properties;
860 k->rtce_window_size = 0x10000000;
861 dc->vmsd = &vmstate_spapr_llan;
862}
863
864static const TypeInfo spapr_vlan_info = {
865 .name = TYPE_VIO_SPAPR_VLAN_DEVICE,
866 .parent = TYPE_VIO_SPAPR_DEVICE,
867 .instance_size = sizeof(SpaprVioVlan),
868 .class_init = spapr_vlan_class_init,
869 .instance_init = spapr_vlan_instance_init,
870 .instance_finalize = spapr_vlan_instance_finalize,
871};
872
873static void spapr_vlan_register_types(void)
874{
875 spapr_register_hypercall(H_REGISTER_LOGICAL_LAN, h_register_logical_lan);
876 spapr_register_hypercall(H_FREE_LOGICAL_LAN, h_free_logical_lan);
877 spapr_register_hypercall(H_SEND_LOGICAL_LAN, h_send_logical_lan);
878 spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER,
879 h_add_logical_lan_buffer);
880 spapr_register_hypercall(H_MULTICAST_CTRL, h_multicast_ctrl);
881 spapr_register_hypercall(H_CHANGE_LOGICAL_LAN_MAC,
882 h_change_logical_lan_mac);
883 type_register_static(&spapr_vlan_info);
884}
885
886type_init(spapr_vlan_register_types)
887