]> git.proxmox.com Git - qemu.git/blob - hw/spapr_llan.c
Merge remote-tracking branch 'stefanha/tracing' into staging
[qemu.git] / hw / spapr_llan.c
1 /*
2 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
3 *
4 * PAPR Inter-VM Logical Lan, aka ibmveth
5 *
6 * Copyright (c) 2010,2011 David Gibson, IBM Corporation.
7 *
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:
14 *
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
17 *
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
24 * THE SOFTWARE.
25 *
26 */
27 #include "hw.h"
28 #include "net.h"
29 #include "hw/qdev.h"
30 #include "hw/spapr.h"
31 #include "hw/spapr_vio.h"
32
33 #include <libfdt.h>
34
35 #define ETH_ALEN 6
36 #define MAX_PACKET_SIZE 65536
37
38 /*#define DEBUG*/
39
40 #ifdef DEBUG
41 #define dprintf(fmt...) do { fprintf(stderr, fmt); } while (0)
42 #else
43 #define dprintf(fmt...)
44 #endif
45
46 /*
47 * Virtual LAN device
48 */
49
50 typedef uint64_t vlan_bd_t;
51
52 #define VLAN_BD_VALID 0x8000000000000000ULL
53 #define VLAN_BD_TOGGLE 0x4000000000000000ULL
54 #define VLAN_BD_NO_CSUM 0x0200000000000000ULL
55 #define VLAN_BD_CSUM_GOOD 0x0100000000000000ULL
56 #define VLAN_BD_LEN_MASK 0x00ffffff00000000ULL
57 #define VLAN_BD_LEN(bd) (((bd) & VLAN_BD_LEN_MASK) >> 32)
58 #define VLAN_BD_ADDR_MASK 0x00000000ffffffffULL
59 #define VLAN_BD_ADDR(bd) ((bd) & VLAN_BD_ADDR_MASK)
60
61 #define VLAN_VALID_BD(addr, len) (VLAN_BD_VALID | \
62 (((len) << 32) & VLAN_BD_LEN_MASK) | \
63 (addr & VLAN_BD_ADDR_MASK))
64
65 #define VLAN_RXQC_TOGGLE 0x80
66 #define VLAN_RXQC_VALID 0x40
67 #define VLAN_RXQC_NO_CSUM 0x02
68 #define VLAN_RXQC_CSUM_GOOD 0x01
69
70 #define VLAN_RQ_ALIGNMENT 16
71 #define VLAN_RXQ_BD_OFF 0
72 #define VLAN_FILTER_BD_OFF 8
73 #define VLAN_RX_BDS_OFF 16
74 #define VLAN_MAX_BUFS ((SPAPR_VIO_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF) / 8)
75
76 typedef struct VIOsPAPRVLANDevice {
77 VIOsPAPRDevice sdev;
78 NICConf nicconf;
79 NICState *nic;
80 int isopen;
81 target_ulong buf_list;
82 int add_buf_ptr, use_buf_ptr, rx_bufs;
83 target_ulong rxq_ptr;
84 } VIOsPAPRVLANDevice;
85
86 static int spapr_vlan_can_receive(VLANClientState *nc)
87 {
88 VIOsPAPRVLANDevice *dev = DO_UPCAST(NICState, nc, nc)->opaque;
89
90 return (dev->isopen && dev->rx_bufs > 0);
91 }
92
93 static ssize_t spapr_vlan_receive(VLANClientState *nc, const uint8_t *buf,
94 size_t size)
95 {
96 VIOsPAPRDevice *sdev = DO_UPCAST(NICState, nc, nc)->opaque;
97 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
98 vlan_bd_t rxq_bd = ldq_tce(sdev, dev->buf_list + VLAN_RXQ_BD_OFF);
99 vlan_bd_t bd;
100 int buf_ptr = dev->use_buf_ptr;
101 uint64_t handle;
102 uint8_t control;
103
104 dprintf("spapr_vlan_receive() [%s] rx_bufs=%d\n", sdev->qdev.id,
105 dev->rx_bufs);
106
107 if (!dev->isopen) {
108 return -1;
109 }
110
111 if (!dev->rx_bufs) {
112 return -1;
113 }
114
115 do {
116 buf_ptr += 8;
117 if (buf_ptr >= SPAPR_VIO_TCE_PAGE_SIZE) {
118 buf_ptr = VLAN_RX_BDS_OFF;
119 }
120
121 bd = ldq_tce(sdev, dev->buf_list + buf_ptr);
122 dprintf("use_buf_ptr=%d bd=0x%016llx\n",
123 buf_ptr, (unsigned long long)bd);
124 } while ((!(bd & VLAN_BD_VALID) || (VLAN_BD_LEN(bd) < (size + 8)))
125 && (buf_ptr != dev->use_buf_ptr));
126
127 if (!(bd & VLAN_BD_VALID) || (VLAN_BD_LEN(bd) < (size + 8))) {
128 /* Failed to find a suitable buffer */
129 return -1;
130 }
131
132 /* Remove the buffer from the pool */
133 dev->rx_bufs--;
134 dev->use_buf_ptr = buf_ptr;
135 stq_tce(sdev, dev->buf_list + dev->use_buf_ptr, 0);
136
137 dprintf("Found buffer: ptr=%d num=%d\n", dev->use_buf_ptr, dev->rx_bufs);
138
139 /* Transfer the packet data */
140 if (spapr_tce_dma_write(sdev, VLAN_BD_ADDR(bd) + 8, buf, size) < 0) {
141 return -1;
142 }
143
144 dprintf("spapr_vlan_receive: DMA write completed\n");
145
146 /* Update the receive queue */
147 control = VLAN_RXQC_TOGGLE | VLAN_RXQC_VALID;
148 if (rxq_bd & VLAN_BD_TOGGLE) {
149 control ^= VLAN_RXQC_TOGGLE;
150 }
151
152 handle = ldq_tce(sdev, VLAN_BD_ADDR(bd));
153 stq_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 8, handle);
154 stw_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 4, size);
155 sth_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 2, 8);
156 stb_tce(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr, control);
157
158 dprintf("wrote rxq entry (ptr=0x%llx): 0x%016llx 0x%016llx\n",
159 (unsigned long long)dev->rxq_ptr,
160 (unsigned long long)ldq_tce(sdev, VLAN_BD_ADDR(rxq_bd) +
161 dev->rxq_ptr),
162 (unsigned long long)ldq_tce(sdev, VLAN_BD_ADDR(rxq_bd) +
163 dev->rxq_ptr + 8));
164
165 dev->rxq_ptr += 16;
166 if (dev->rxq_ptr >= VLAN_BD_LEN(rxq_bd)) {
167 dev->rxq_ptr = 0;
168 stq_tce(sdev, dev->buf_list + VLAN_RXQ_BD_OFF, rxq_bd ^ VLAN_BD_TOGGLE);
169 }
170
171 if (sdev->signal_state & 1) {
172 qemu_irq_pulse(sdev->qirq);
173 }
174
175 return size;
176 }
177
178 static NetClientInfo net_spapr_vlan_info = {
179 .type = NET_CLIENT_TYPE_NIC,
180 .size = sizeof(NICState),
181 .can_receive = spapr_vlan_can_receive,
182 .receive = spapr_vlan_receive,
183 };
184
185 static void spapr_vlan_reset(VIOsPAPRDevice *sdev)
186 {
187 VIOsPAPRVLANDevice *dev = DO_UPCAST(VIOsPAPRVLANDevice, sdev, sdev);
188
189 dev->buf_list = 0;
190 dev->rx_bufs = 0;
191 dev->isopen = 0;
192 }
193
194 static int spapr_vlan_init(VIOsPAPRDevice *sdev)
195 {
196 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
197
198 qemu_macaddr_default_if_unset(&dev->nicconf.macaddr);
199
200 dev->nic = qemu_new_nic(&net_spapr_vlan_info, &dev->nicconf,
201 object_get_typename(OBJECT(sdev)), sdev->qdev.id, dev);
202 qemu_format_nic_info_str(&dev->nic->nc, dev->nicconf.macaddr.a);
203
204 return 0;
205 }
206
207 void spapr_vlan_create(VIOsPAPRBus *bus, NICInfo *nd)
208 {
209 DeviceState *dev;
210
211 dev = qdev_create(&bus->bus, "spapr-vlan");
212
213 qdev_set_nic_properties(dev, nd);
214
215 qdev_init_nofail(dev);
216 }
217
218 static int spapr_vlan_devnode(VIOsPAPRDevice *dev, void *fdt, int node_off)
219 {
220 VIOsPAPRVLANDevice *vdev = (VIOsPAPRVLANDevice *)dev;
221 uint8_t padded_mac[8] = {0, 0};
222 int ret;
223
224 /* Some old phyp versions give the mac address in an 8-byte
225 * property. The kernel driver has an insane workaround for this;
226 * rather than doing the obvious thing and checking the property
227 * length, it checks whether the first byte has 0b10 in the low
228 * bits. If a correct 6-byte property has a different first byte
229 * the kernel will get the wrong mac address, overrunning its
230 * buffer in the process (read only, thank goodness).
231 *
232 * Here we workaround the kernel workaround by always supplying an
233 * 8-byte property, with the mac address in the last six bytes */
234 memcpy(&padded_mac[2], &vdev->nicconf.macaddr, ETH_ALEN);
235 ret = fdt_setprop(fdt, node_off, "local-mac-address",
236 padded_mac, sizeof(padded_mac));
237 if (ret < 0) {
238 return ret;
239 }
240
241 ret = fdt_setprop_cell(fdt, node_off, "ibm,mac-address-filters", 0);
242 if (ret < 0) {
243 return ret;
244 }
245
246 return 0;
247 }
248
249 static int check_bd(VIOsPAPRVLANDevice *dev, vlan_bd_t bd,
250 target_ulong alignment)
251 {
252 if ((VLAN_BD_ADDR(bd) % alignment)
253 || (VLAN_BD_LEN(bd) % alignment)) {
254 return -1;
255 }
256
257 if (spapr_vio_check_tces(&dev->sdev, VLAN_BD_ADDR(bd),
258 VLAN_BD_LEN(bd), SPAPR_TCE_RW) != 0) {
259 return -1;
260 }
261
262 return 0;
263 }
264
265 static target_ulong h_register_logical_lan(CPUPPCState *env,
266 sPAPREnvironment *spapr,
267 target_ulong opcode,
268 target_ulong *args)
269 {
270 target_ulong reg = args[0];
271 target_ulong buf_list = args[1];
272 target_ulong rec_queue = args[2];
273 target_ulong filter_list = args[3];
274 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
275 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
276 vlan_bd_t filter_list_bd;
277
278 if (!dev) {
279 return H_PARAMETER;
280 }
281
282 if (dev->isopen) {
283 hcall_dprintf("H_REGISTER_LOGICAL_LAN called twice without "
284 "H_FREE_LOGICAL_LAN\n");
285 return H_RESOURCE;
286 }
287
288 if (check_bd(dev, VLAN_VALID_BD(buf_list, SPAPR_VIO_TCE_PAGE_SIZE),
289 SPAPR_VIO_TCE_PAGE_SIZE) < 0) {
290 hcall_dprintf("Bad buf_list 0x" TARGET_FMT_lx "\n", buf_list);
291 return H_PARAMETER;
292 }
293
294 filter_list_bd = VLAN_VALID_BD(filter_list, SPAPR_VIO_TCE_PAGE_SIZE);
295 if (check_bd(dev, filter_list_bd, SPAPR_VIO_TCE_PAGE_SIZE) < 0) {
296 hcall_dprintf("Bad filter_list 0x" TARGET_FMT_lx "\n", filter_list);
297 return H_PARAMETER;
298 }
299
300 if (!(rec_queue & VLAN_BD_VALID)
301 || (check_bd(dev, rec_queue, VLAN_RQ_ALIGNMENT) < 0)) {
302 hcall_dprintf("Bad receive queue\n");
303 return H_PARAMETER;
304 }
305
306 dev->buf_list = buf_list;
307 sdev->signal_state = 0;
308
309 rec_queue &= ~VLAN_BD_TOGGLE;
310
311 /* Initialize the buffer list */
312 stq_tce(sdev, buf_list, rec_queue);
313 stq_tce(sdev, buf_list + 8, filter_list_bd);
314 spapr_tce_dma_zero(sdev, buf_list + VLAN_RX_BDS_OFF,
315 SPAPR_VIO_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF);
316 dev->add_buf_ptr = VLAN_RX_BDS_OFF - 8;
317 dev->use_buf_ptr = VLAN_RX_BDS_OFF - 8;
318 dev->rx_bufs = 0;
319 dev->rxq_ptr = 0;
320
321 /* Initialize the receive queue */
322 spapr_tce_dma_zero(sdev, VLAN_BD_ADDR(rec_queue), VLAN_BD_LEN(rec_queue));
323
324 dev->isopen = 1;
325 return H_SUCCESS;
326 }
327
328
329 static target_ulong h_free_logical_lan(CPUPPCState *env, sPAPREnvironment *spapr,
330 target_ulong opcode, target_ulong *args)
331 {
332 target_ulong reg = args[0];
333 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
334 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
335
336 if (!dev) {
337 return H_PARAMETER;
338 }
339
340 if (!dev->isopen) {
341 hcall_dprintf("H_FREE_LOGICAL_LAN called without "
342 "H_REGISTER_LOGICAL_LAN\n");
343 return H_RESOURCE;
344 }
345
346 spapr_vlan_reset(sdev);
347 return H_SUCCESS;
348 }
349
350 static target_ulong h_add_logical_lan_buffer(CPUPPCState *env,
351 sPAPREnvironment *spapr,
352 target_ulong opcode,
353 target_ulong *args)
354 {
355 target_ulong reg = args[0];
356 target_ulong buf = args[1];
357 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
358 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
359 vlan_bd_t bd;
360
361 dprintf("H_ADD_LOGICAL_LAN_BUFFER(0x" TARGET_FMT_lx
362 ", 0x" TARGET_FMT_lx ")\n", reg, buf);
363
364 if (!sdev) {
365 hcall_dprintf("Bad device\n");
366 return H_PARAMETER;
367 }
368
369 if ((check_bd(dev, buf, 4) < 0)
370 || (VLAN_BD_LEN(buf) < 16)) {
371 hcall_dprintf("Bad buffer enqueued\n");
372 return H_PARAMETER;
373 }
374
375 if (!dev->isopen || dev->rx_bufs >= VLAN_MAX_BUFS) {
376 return H_RESOURCE;
377 }
378
379 do {
380 dev->add_buf_ptr += 8;
381 if (dev->add_buf_ptr >= SPAPR_VIO_TCE_PAGE_SIZE) {
382 dev->add_buf_ptr = VLAN_RX_BDS_OFF;
383 }
384
385 bd = ldq_tce(sdev, dev->buf_list + dev->add_buf_ptr);
386 } while (bd & VLAN_BD_VALID);
387
388 stq_tce(sdev, dev->buf_list + dev->add_buf_ptr, buf);
389
390 dev->rx_bufs++;
391
392 dprintf("h_add_logical_lan_buffer(): Added buf ptr=%d rx_bufs=%d"
393 " bd=0x%016llx\n", dev->add_buf_ptr, dev->rx_bufs,
394 (unsigned long long)buf);
395
396 return H_SUCCESS;
397 }
398
399 static target_ulong h_send_logical_lan(CPUPPCState *env, sPAPREnvironment *spapr,
400 target_ulong opcode, target_ulong *args)
401 {
402 target_ulong reg = args[0];
403 target_ulong *bufs = args + 1;
404 target_ulong continue_token = args[7];
405 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
406 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
407 unsigned total_len;
408 uint8_t *lbuf, *p;
409 int i, nbufs;
410 int ret;
411
412 dprintf("H_SEND_LOGICAL_LAN(0x" TARGET_FMT_lx ", <bufs>, 0x"
413 TARGET_FMT_lx ")\n", reg, continue_token);
414
415 if (!sdev) {
416 return H_PARAMETER;
417 }
418
419 dprintf("rxbufs = %d\n", dev->rx_bufs);
420
421 if (!dev->isopen) {
422 return H_DROPPED;
423 }
424
425 if (continue_token) {
426 return H_HARDWARE; /* FIXME actually handle this */
427 }
428
429 total_len = 0;
430 for (i = 0; i < 6; i++) {
431 dprintf(" buf desc: 0x" TARGET_FMT_lx "\n", bufs[i]);
432 if (!(bufs[i] & VLAN_BD_VALID)) {
433 break;
434 }
435 total_len += VLAN_BD_LEN(bufs[i]);
436 }
437
438 nbufs = i;
439 dprintf("h_send_logical_lan() %d buffers, total length 0x%x\n",
440 nbufs, total_len);
441
442 if (total_len == 0) {
443 return H_SUCCESS;
444 }
445
446 if (total_len > MAX_PACKET_SIZE) {
447 /* Don't let the guest force too large an allocation */
448 return H_RESOURCE;
449 }
450
451 lbuf = alloca(total_len);
452 p = lbuf;
453 for (i = 0; i < nbufs; i++) {
454 ret = spapr_tce_dma_read(sdev, VLAN_BD_ADDR(bufs[i]),
455 p, VLAN_BD_LEN(bufs[i]));
456 if (ret < 0) {
457 return ret;
458 }
459
460 p += VLAN_BD_LEN(bufs[i]);
461 }
462
463 qemu_send_packet(&dev->nic->nc, lbuf, total_len);
464
465 return H_SUCCESS;
466 }
467
468 static target_ulong h_multicast_ctrl(CPUPPCState *env, sPAPREnvironment *spapr,
469 target_ulong opcode, target_ulong *args)
470 {
471 target_ulong reg = args[0];
472 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
473
474 if (!dev) {
475 return H_PARAMETER;
476 }
477
478 return H_SUCCESS;
479 }
480
481 static Property spapr_vlan_properties[] = {
482 DEFINE_SPAPR_PROPERTIES(VIOsPAPRVLANDevice, sdev, 0x10000000),
483 DEFINE_NIC_PROPERTIES(VIOsPAPRVLANDevice, nicconf),
484 DEFINE_PROP_END_OF_LIST(),
485 };
486
487 static void spapr_vlan_class_init(ObjectClass *klass, void *data)
488 {
489 DeviceClass *dc = DEVICE_CLASS(klass);
490 VIOsPAPRDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass);
491
492 k->init = spapr_vlan_init;
493 k->reset = spapr_vlan_reset;
494 k->devnode = spapr_vlan_devnode;
495 k->dt_name = "l-lan";
496 k->dt_type = "network";
497 k->dt_compatible = "IBM,l-lan";
498 k->signal_mask = 0x1;
499 dc->props = spapr_vlan_properties;
500 }
501
502 static TypeInfo spapr_vlan_info = {
503 .name = "spapr-vlan",
504 .parent = TYPE_VIO_SPAPR_DEVICE,
505 .instance_size = sizeof(VIOsPAPRVLANDevice),
506 .class_init = spapr_vlan_class_init,
507 };
508
509 static void spapr_vlan_register_types(void)
510 {
511 spapr_register_hypercall(H_REGISTER_LOGICAL_LAN, h_register_logical_lan);
512 spapr_register_hypercall(H_FREE_LOGICAL_LAN, h_free_logical_lan);
513 spapr_register_hypercall(H_SEND_LOGICAL_LAN, h_send_logical_lan);
514 spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER,
515 h_add_logical_lan_buffer);
516 spapr_register_hypercall(H_MULTICAST_CTRL, h_multicast_ctrl);
517 type_register_static(&spapr_vlan_info);
518 }
519
520 type_init(spapr_vlan_register_types)