]> git.proxmox.com Git - qemu.git/blob - hw/spapr_llan.c
pseries: Fix reset of VIO network device
[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, uint32_t reg, NICInfo *nd)
208 {
209 DeviceState *dev;
210
211 dev = qdev_create(&bus->bus, "spapr-vlan");
212 qdev_prop_set_uint32(dev, "reg", reg);
213
214 qdev_set_nic_properties(dev, nd);
215
216 qdev_init_nofail(dev);
217 }
218
219 static int spapr_vlan_devnode(VIOsPAPRDevice *dev, void *fdt, int node_off)
220 {
221 VIOsPAPRVLANDevice *vdev = (VIOsPAPRVLANDevice *)dev;
222 uint8_t padded_mac[8] = {0, 0};
223 int ret;
224
225 /* Some old phyp versions give the mac address in an 8-byte
226 * property. The kernel driver has an insane workaround for this;
227 * rather than doing the obvious thing and checking the property
228 * length, it checks whether the first byte has 0b10 in the low
229 * bits. If a correct 6-byte property has a different first byte
230 * the kernel will get the wrong mac address, overrunning its
231 * buffer in the process (read only, thank goodness).
232 *
233 * Here we workaround the kernel workaround by always supplying an
234 * 8-byte property, with the mac address in the last six bytes */
235 memcpy(&padded_mac[2], &vdev->nicconf.macaddr, ETH_ALEN);
236 ret = fdt_setprop(fdt, node_off, "local-mac-address",
237 padded_mac, sizeof(padded_mac));
238 if (ret < 0) {
239 return ret;
240 }
241
242 ret = fdt_setprop_cell(fdt, node_off, "ibm,mac-address-filters", 0);
243 if (ret < 0) {
244 return ret;
245 }
246
247 return 0;
248 }
249
250 static int check_bd(VIOsPAPRVLANDevice *dev, vlan_bd_t bd,
251 target_ulong alignment)
252 {
253 if ((VLAN_BD_ADDR(bd) % alignment)
254 || (VLAN_BD_LEN(bd) % alignment)) {
255 return -1;
256 }
257
258 if (spapr_vio_check_tces(&dev->sdev, VLAN_BD_ADDR(bd),
259 VLAN_BD_LEN(bd), SPAPR_TCE_RW) != 0) {
260 return -1;
261 }
262
263 return 0;
264 }
265
266 static target_ulong h_register_logical_lan(CPUPPCState *env,
267 sPAPREnvironment *spapr,
268 target_ulong opcode,
269 target_ulong *args)
270 {
271 target_ulong reg = args[0];
272 target_ulong buf_list = args[1];
273 target_ulong rec_queue = args[2];
274 target_ulong filter_list = args[3];
275 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
276 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
277 vlan_bd_t filter_list_bd;
278
279 if (!dev) {
280 return H_PARAMETER;
281 }
282
283 if (dev->isopen) {
284 hcall_dprintf("H_REGISTER_LOGICAL_LAN called twice without "
285 "H_FREE_LOGICAL_LAN\n");
286 return H_RESOURCE;
287 }
288
289 if (check_bd(dev, VLAN_VALID_BD(buf_list, SPAPR_VIO_TCE_PAGE_SIZE),
290 SPAPR_VIO_TCE_PAGE_SIZE) < 0) {
291 hcall_dprintf("Bad buf_list 0x" TARGET_FMT_lx "\n", buf_list);
292 return H_PARAMETER;
293 }
294
295 filter_list_bd = VLAN_VALID_BD(filter_list, SPAPR_VIO_TCE_PAGE_SIZE);
296 if (check_bd(dev, filter_list_bd, SPAPR_VIO_TCE_PAGE_SIZE) < 0) {
297 hcall_dprintf("Bad filter_list 0x" TARGET_FMT_lx "\n", filter_list);
298 return H_PARAMETER;
299 }
300
301 if (!(rec_queue & VLAN_BD_VALID)
302 || (check_bd(dev, rec_queue, VLAN_RQ_ALIGNMENT) < 0)) {
303 hcall_dprintf("Bad receive queue\n");
304 return H_PARAMETER;
305 }
306
307 dev->buf_list = buf_list;
308 sdev->signal_state = 0;
309
310 rec_queue &= ~VLAN_BD_TOGGLE;
311
312 /* Initialize the buffer list */
313 stq_tce(sdev, buf_list, rec_queue);
314 stq_tce(sdev, buf_list + 8, filter_list_bd);
315 spapr_tce_dma_zero(sdev, buf_list + VLAN_RX_BDS_OFF,
316 SPAPR_VIO_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF);
317 dev->add_buf_ptr = VLAN_RX_BDS_OFF - 8;
318 dev->use_buf_ptr = VLAN_RX_BDS_OFF - 8;
319 dev->rx_bufs = 0;
320 dev->rxq_ptr = 0;
321
322 /* Initialize the receive queue */
323 spapr_tce_dma_zero(sdev, VLAN_BD_ADDR(rec_queue), VLAN_BD_LEN(rec_queue));
324
325 dev->isopen = 1;
326 return H_SUCCESS;
327 }
328
329
330 static target_ulong h_free_logical_lan(CPUPPCState *env, sPAPREnvironment *spapr,
331 target_ulong opcode, target_ulong *args)
332 {
333 target_ulong reg = args[0];
334 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
335 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
336
337 if (!dev) {
338 return H_PARAMETER;
339 }
340
341 if (!dev->isopen) {
342 hcall_dprintf("H_FREE_LOGICAL_LAN called without "
343 "H_REGISTER_LOGICAL_LAN\n");
344 return H_RESOURCE;
345 }
346
347 spapr_vlan_reset(sdev);
348 return H_SUCCESS;
349 }
350
351 static target_ulong h_add_logical_lan_buffer(CPUPPCState *env,
352 sPAPREnvironment *spapr,
353 target_ulong opcode,
354 target_ulong *args)
355 {
356 target_ulong reg = args[0];
357 target_ulong buf = args[1];
358 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
359 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
360 vlan_bd_t bd;
361
362 dprintf("H_ADD_LOGICAL_LAN_BUFFER(0x" TARGET_FMT_lx
363 ", 0x" TARGET_FMT_lx ")\n", reg, buf);
364
365 if (!sdev) {
366 hcall_dprintf("Bad device\n");
367 return H_PARAMETER;
368 }
369
370 if ((check_bd(dev, buf, 4) < 0)
371 || (VLAN_BD_LEN(buf) < 16)) {
372 hcall_dprintf("Bad buffer enqueued\n");
373 return H_PARAMETER;
374 }
375
376 if (!dev->isopen || dev->rx_bufs >= VLAN_MAX_BUFS) {
377 return H_RESOURCE;
378 }
379
380 do {
381 dev->add_buf_ptr += 8;
382 if (dev->add_buf_ptr >= SPAPR_VIO_TCE_PAGE_SIZE) {
383 dev->add_buf_ptr = VLAN_RX_BDS_OFF;
384 }
385
386 bd = ldq_tce(sdev, dev->buf_list + dev->add_buf_ptr);
387 } while (bd & VLAN_BD_VALID);
388
389 stq_tce(sdev, dev->buf_list + dev->add_buf_ptr, buf);
390
391 dev->rx_bufs++;
392
393 dprintf("h_add_logical_lan_buffer(): Added buf ptr=%d rx_bufs=%d"
394 " bd=0x%016llx\n", dev->add_buf_ptr, dev->rx_bufs,
395 (unsigned long long)buf);
396
397 return H_SUCCESS;
398 }
399
400 static target_ulong h_send_logical_lan(CPUPPCState *env, sPAPREnvironment *spapr,
401 target_ulong opcode, target_ulong *args)
402 {
403 target_ulong reg = args[0];
404 target_ulong *bufs = args + 1;
405 target_ulong continue_token = args[7];
406 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
407 VIOsPAPRVLANDevice *dev = (VIOsPAPRVLANDevice *)sdev;
408 unsigned total_len;
409 uint8_t *lbuf, *p;
410 int i, nbufs;
411 int ret;
412
413 dprintf("H_SEND_LOGICAL_LAN(0x" TARGET_FMT_lx ", <bufs>, 0x"
414 TARGET_FMT_lx ")\n", reg, continue_token);
415
416 if (!sdev) {
417 return H_PARAMETER;
418 }
419
420 dprintf("rxbufs = %d\n", dev->rx_bufs);
421
422 if (!dev->isopen) {
423 return H_DROPPED;
424 }
425
426 if (continue_token) {
427 return H_HARDWARE; /* FIXME actually handle this */
428 }
429
430 total_len = 0;
431 for (i = 0; i < 6; i++) {
432 dprintf(" buf desc: 0x" TARGET_FMT_lx "\n", bufs[i]);
433 if (!(bufs[i] & VLAN_BD_VALID)) {
434 break;
435 }
436 total_len += VLAN_BD_LEN(bufs[i]);
437 }
438
439 nbufs = i;
440 dprintf("h_send_logical_lan() %d buffers, total length 0x%x\n",
441 nbufs, total_len);
442
443 if (total_len == 0) {
444 return H_SUCCESS;
445 }
446
447 if (total_len > MAX_PACKET_SIZE) {
448 /* Don't let the guest force too large an allocation */
449 return H_RESOURCE;
450 }
451
452 lbuf = alloca(total_len);
453 p = lbuf;
454 for (i = 0; i < nbufs; i++) {
455 ret = spapr_tce_dma_read(sdev, VLAN_BD_ADDR(bufs[i]),
456 p, VLAN_BD_LEN(bufs[i]));
457 if (ret < 0) {
458 return ret;
459 }
460
461 p += VLAN_BD_LEN(bufs[i]);
462 }
463
464 qemu_send_packet(&dev->nic->nc, lbuf, total_len);
465
466 return H_SUCCESS;
467 }
468
469 static target_ulong h_multicast_ctrl(CPUPPCState *env, sPAPREnvironment *spapr,
470 target_ulong opcode, target_ulong *args)
471 {
472 target_ulong reg = args[0];
473 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
474
475 if (!dev) {
476 return H_PARAMETER;
477 }
478
479 return H_SUCCESS;
480 }
481
482 static Property spapr_vlan_properties[] = {
483 DEFINE_SPAPR_PROPERTIES(VIOsPAPRVLANDevice, sdev, 0x1000, 0x10000000),
484 DEFINE_NIC_PROPERTIES(VIOsPAPRVLANDevice, nicconf),
485 DEFINE_PROP_END_OF_LIST(),
486 };
487
488 static void spapr_vlan_class_init(ObjectClass *klass, void *data)
489 {
490 DeviceClass *dc = DEVICE_CLASS(klass);
491 VIOsPAPRDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass);
492
493 k->init = spapr_vlan_init;
494 k->reset = spapr_vlan_reset;
495 k->devnode = spapr_vlan_devnode;
496 k->dt_name = "l-lan";
497 k->dt_type = "network";
498 k->dt_compatible = "IBM,l-lan";
499 k->signal_mask = 0x1;
500 dc->props = spapr_vlan_properties;
501 }
502
503 static TypeInfo spapr_vlan_info = {
504 .name = "spapr-vlan",
505 .parent = TYPE_VIO_SPAPR_DEVICE,
506 .instance_size = sizeof(VIOsPAPRVLANDevice),
507 .class_init = spapr_vlan_class_init,
508 };
509
510 static void spapr_vlan_register_types(void)
511 {
512 spapr_register_hypercall(H_REGISTER_LOGICAL_LAN, h_register_logical_lan);
513 spapr_register_hypercall(H_FREE_LOGICAL_LAN, h_free_logical_lan);
514 spapr_register_hypercall(H_SEND_LOGICAL_LAN, h_send_logical_lan);
515 spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER,
516 h_add_logical_lan_buffer);
517 spapr_register_hypercall(H_MULTICAST_CTRL, h_multicast_ctrl);
518 type_register_static(&spapr_vlan_info);
519 }
520
521 type_init(spapr_vlan_register_types)