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/hw.h" 28 #include "net/net.h" 29 #include "hw/qdev.h" 30 #include "hw/ppc/spapr.h" 31 #include "hw/ppc/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_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF) / 8) 75 76 #define TYPE_VIO_SPAPR_VLAN_DEVICE "spapr-vlan" 77 #define VIO_SPAPR_VLAN_DEVICE(obj) \ 78 OBJECT_CHECK(VIOsPAPRVLANDevice, (obj), TYPE_VIO_SPAPR_VLAN_DEVICE) 79 80 typedef struct VIOsPAPRVLANDevice { 81 VIOsPAPRDevice sdev; 82 NICConf nicconf; 83 NICState *nic; 84 int isopen; 85 target_ulong buf_list; 86 int add_buf_ptr, use_buf_ptr, rx_bufs; 87 target_ulong rxq_ptr; 88 } VIOsPAPRVLANDevice; 89 90 static int spapr_vlan_can_receive(NetClientState *nc) 91 { 92 VIOsPAPRVLANDevice *dev = qemu_get_nic_opaque(nc); 93 94 return (dev->isopen && dev->rx_bufs > 0); 95 } 96 97 static ssize_t spapr_vlan_receive(NetClientState *nc, const uint8_t *buf, 98 size_t size) 99 { 100 VIOsPAPRVLANDevice *dev = qemu_get_nic_opaque(nc); 101 VIOsPAPRDevice *sdev = VIO_SPAPR_DEVICE(dev); 102 vlan_bd_t rxq_bd = vio_ldq(sdev, dev->buf_list + VLAN_RXQ_BD_OFF); 103 vlan_bd_t bd; 104 int buf_ptr = dev->use_buf_ptr; 105 uint64_t handle; 106 uint8_t control; 107 108 dprintf("spapr_vlan_receive() [%s] rx_bufs=%d\n", sdev->qdev.id, 109 dev->rx_bufs); 110 111 if (!dev->isopen) { 112 return -1; 113 } 114 115 if (!dev->rx_bufs) { 116 return -1; 117 } 118 119 do { 120 buf_ptr += 8; 121 if (buf_ptr >= SPAPR_TCE_PAGE_SIZE) { 122 buf_ptr = VLAN_RX_BDS_OFF; 123 } 124 125 bd = vio_ldq(sdev, dev->buf_list + buf_ptr); 126 dprintf("use_buf_ptr=%d bd=0x%016llx\n", 127 buf_ptr, (unsigned long long)bd); 128 } while ((!(bd & VLAN_BD_VALID) || (VLAN_BD_LEN(bd) < (size + 8))) 129 && (buf_ptr != dev->use_buf_ptr)); 130 131 if (!(bd & VLAN_BD_VALID) || (VLAN_BD_LEN(bd) < (size + 8))) { 132 /* Failed to find a suitable buffer */ 133 return -1; 134 } 135 136 /* Remove the buffer from the pool */ 137 dev->rx_bufs--; 138 dev->use_buf_ptr = buf_ptr; 139 vio_stq(sdev, dev->buf_list + dev->use_buf_ptr, 0); 140 141 dprintf("Found buffer: ptr=%d num=%d\n", dev->use_buf_ptr, dev->rx_bufs); 142 143 /* Transfer the packet data */ 144 if (spapr_vio_dma_write(sdev, VLAN_BD_ADDR(bd) + 8, buf, size) < 0) { 145 return -1; 146 } 147 148 dprintf("spapr_vlan_receive: DMA write completed\n"); 149 150 /* Update the receive queue */ 151 control = VLAN_RXQC_TOGGLE | VLAN_RXQC_VALID; 152 if (rxq_bd & VLAN_BD_TOGGLE) { 153 control ^= VLAN_RXQC_TOGGLE; 154 } 155 156 handle = vio_ldq(sdev, VLAN_BD_ADDR(bd)); 157 vio_stq(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 8, handle); 158 vio_stl(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 4, size); 159 vio_sth(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr + 2, 8); 160 vio_stb(sdev, VLAN_BD_ADDR(rxq_bd) + dev->rxq_ptr, control); 161 162 dprintf("wrote rxq entry (ptr=0x%llx): 0x%016llx 0x%016llx\n", 163 (unsigned long long)dev->rxq_ptr, 164 (unsigned long long)vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) + 165 dev->rxq_ptr), 166 (unsigned long long)vio_ldq(sdev, VLAN_BD_ADDR(rxq_bd) + 167 dev->rxq_ptr + 8)); 168 169 dev->rxq_ptr += 16; 170 if (dev->rxq_ptr >= VLAN_BD_LEN(rxq_bd)) { 171 dev->rxq_ptr = 0; 172 vio_stq(sdev, dev->buf_list + VLAN_RXQ_BD_OFF, rxq_bd ^ VLAN_BD_TOGGLE); 173 } 174 175 if (sdev->signal_state & 1) { 176 qemu_irq_pulse(spapr_vio_qirq(sdev)); 177 } 178 179 return size; 180 } 181 182 static void spapr_vlan_cleanup(NetClientState *nc) 183 { 184 VIOsPAPRVLANDevice *dev = qemu_get_nic_opaque(nc); 185 186 dev->nic = NULL; 187 } 188 189 static NetClientInfo net_spapr_vlan_info = { 190 .type = NET_CLIENT_OPTIONS_KIND_NIC, 191 .size = sizeof(NICState), 192 .can_receive = spapr_vlan_can_receive, 193 .receive = spapr_vlan_receive, 194 .cleanup = spapr_vlan_cleanup, 195 }; 196 197 static void spapr_vlan_reset(VIOsPAPRDevice *sdev) 198 { 199 VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev); 200 201 dev->buf_list = 0; 202 dev->rx_bufs = 0; 203 dev->isopen = 0; 204 } 205 206 static int spapr_vlan_init(VIOsPAPRDevice *sdev) 207 { 208 VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev); 209 210 qemu_macaddr_default_if_unset(&dev->nicconf.macaddr); 211 212 dev->nic = qemu_new_nic(&net_spapr_vlan_info, &dev->nicconf, 213 object_get_typename(OBJECT(sdev)), sdev->qdev.id, dev); 214 qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a); 215 216 return 0; 217 } 218 219 void spapr_vlan_create(VIOsPAPRBus *bus, NICInfo *nd) 220 { 221 DeviceState *dev; 222 223 dev = qdev_create(&bus->bus, "spapr-vlan"); 224 225 qdev_set_nic_properties(dev, nd); 226 227 qdev_init_nofail(dev); 228 } 229 230 static int spapr_vlan_devnode(VIOsPAPRDevice *dev, void *fdt, int node_off) 231 { 232 VIOsPAPRVLANDevice *vdev = VIO_SPAPR_VLAN_DEVICE(dev); 233 uint8_t padded_mac[8] = {0, 0}; 234 int ret; 235 236 /* Some old phyp versions give the mac address in an 8-byte 237 * property. The kernel driver has an insane workaround for this; 238 * rather than doing the obvious thing and checking the property 239 * length, it checks whether the first byte has 0b10 in the low 240 * bits. If a correct 6-byte property has a different first byte 241 * the kernel will get the wrong mac address, overrunning its 242 * buffer in the process (read only, thank goodness). 243 * 244 * Here we workaround the kernel workaround by always supplying an 245 * 8-byte property, with the mac address in the last six bytes */ 246 memcpy(&padded_mac[2], &vdev->nicconf.macaddr, ETH_ALEN); 247 ret = fdt_setprop(fdt, node_off, "local-mac-address", 248 padded_mac, sizeof(padded_mac)); 249 if (ret < 0) { 250 return ret; 251 } 252 253 ret = fdt_setprop_cell(fdt, node_off, "ibm,mac-address-filters", 0); 254 if (ret < 0) { 255 return ret; 256 } 257 258 return 0; 259 } 260 261 static int check_bd(VIOsPAPRVLANDevice *dev, vlan_bd_t bd, 262 target_ulong alignment) 263 { 264 if ((VLAN_BD_ADDR(bd) % alignment) 265 || (VLAN_BD_LEN(bd) % alignment)) { 266 return -1; 267 } 268 269 if (!spapr_vio_dma_valid(&dev->sdev, VLAN_BD_ADDR(bd), 270 VLAN_BD_LEN(bd), DMA_DIRECTION_FROM_DEVICE) 271 || !spapr_vio_dma_valid(&dev->sdev, VLAN_BD_ADDR(bd), 272 VLAN_BD_LEN(bd), DMA_DIRECTION_TO_DEVICE)) { 273 return -1; 274 } 275 276 return 0; 277 } 278 279 static target_ulong h_register_logical_lan(PowerPCCPU *cpu, 280 sPAPREnvironment *spapr, 281 target_ulong opcode, 282 target_ulong *args) 283 { 284 target_ulong reg = args[0]; 285 target_ulong buf_list = args[1]; 286 target_ulong rec_queue = args[2]; 287 target_ulong filter_list = args[3]; 288 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 289 VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev); 290 vlan_bd_t filter_list_bd; 291 292 if (!dev) { 293 return H_PARAMETER; 294 } 295 296 if (dev->isopen) { 297 hcall_dprintf("H_REGISTER_LOGICAL_LAN called twice without " 298 "H_FREE_LOGICAL_LAN\n"); 299 return H_RESOURCE; 300 } 301 302 if (check_bd(dev, VLAN_VALID_BD(buf_list, SPAPR_TCE_PAGE_SIZE), 303 SPAPR_TCE_PAGE_SIZE) < 0) { 304 hcall_dprintf("Bad buf_list 0x" TARGET_FMT_lx "\n", buf_list); 305 return H_PARAMETER; 306 } 307 308 filter_list_bd = VLAN_VALID_BD(filter_list, SPAPR_TCE_PAGE_SIZE); 309 if (check_bd(dev, filter_list_bd, SPAPR_TCE_PAGE_SIZE) < 0) { 310 hcall_dprintf("Bad filter_list 0x" TARGET_FMT_lx "\n", filter_list); 311 return H_PARAMETER; 312 } 313 314 if (!(rec_queue & VLAN_BD_VALID) 315 || (check_bd(dev, rec_queue, VLAN_RQ_ALIGNMENT) < 0)) { 316 hcall_dprintf("Bad receive queue\n"); 317 return H_PARAMETER; 318 } 319 320 dev->buf_list = buf_list; 321 sdev->signal_state = 0; 322 323 rec_queue &= ~VLAN_BD_TOGGLE; 324 325 /* Initialize the buffer list */ 326 vio_stq(sdev, buf_list, rec_queue); 327 vio_stq(sdev, buf_list + 8, filter_list_bd); 328 spapr_vio_dma_set(sdev, buf_list + VLAN_RX_BDS_OFF, 0, 329 SPAPR_TCE_PAGE_SIZE - VLAN_RX_BDS_OFF); 330 dev->add_buf_ptr = VLAN_RX_BDS_OFF - 8; 331 dev->use_buf_ptr = VLAN_RX_BDS_OFF - 8; 332 dev->rx_bufs = 0; 333 dev->rxq_ptr = 0; 334 335 /* Initialize the receive queue */ 336 spapr_vio_dma_set(sdev, VLAN_BD_ADDR(rec_queue), 0, VLAN_BD_LEN(rec_queue)); 337 338 dev->isopen = 1; 339 return H_SUCCESS; 340 } 341 342 343 static target_ulong h_free_logical_lan(PowerPCCPU *cpu, sPAPREnvironment *spapr, 344 target_ulong opcode, target_ulong *args) 345 { 346 target_ulong reg = args[0]; 347 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 348 VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev); 349 350 if (!dev) { 351 return H_PARAMETER; 352 } 353 354 if (!dev->isopen) { 355 hcall_dprintf("H_FREE_LOGICAL_LAN called without " 356 "H_REGISTER_LOGICAL_LAN\n"); 357 return H_RESOURCE; 358 } 359 360 spapr_vlan_reset(sdev); 361 return H_SUCCESS; 362 } 363 364 static target_ulong h_add_logical_lan_buffer(PowerPCCPU *cpu, 365 sPAPREnvironment *spapr, 366 target_ulong opcode, 367 target_ulong *args) 368 { 369 target_ulong reg = args[0]; 370 target_ulong buf = args[1]; 371 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 372 VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev); 373 vlan_bd_t bd; 374 375 dprintf("H_ADD_LOGICAL_LAN_BUFFER(0x" TARGET_FMT_lx 376 ", 0x" TARGET_FMT_lx ")\n", reg, buf); 377 378 if (!sdev) { 379 hcall_dprintf("Bad device\n"); 380 return H_PARAMETER; 381 } 382 383 if ((check_bd(dev, buf, 4) < 0) 384 || (VLAN_BD_LEN(buf) < 16)) { 385 hcall_dprintf("Bad buffer enqueued\n"); 386 return H_PARAMETER; 387 } 388 389 if (!dev->isopen || dev->rx_bufs >= VLAN_MAX_BUFS) { 390 return H_RESOURCE; 391 } 392 393 do { 394 dev->add_buf_ptr += 8; 395 if (dev->add_buf_ptr >= SPAPR_TCE_PAGE_SIZE) { 396 dev->add_buf_ptr = VLAN_RX_BDS_OFF; 397 } 398 399 bd = vio_ldq(sdev, dev->buf_list + dev->add_buf_ptr); 400 } while (bd & VLAN_BD_VALID); 401 402 vio_stq(sdev, dev->buf_list + dev->add_buf_ptr, buf); 403 404 dev->rx_bufs++; 405 406 dprintf("h_add_logical_lan_buffer(): Added buf ptr=%d rx_bufs=%d" 407 " bd=0x%016llx\n", dev->add_buf_ptr, dev->rx_bufs, 408 (unsigned long long)buf); 409 410 return H_SUCCESS; 411 } 412 413 static target_ulong h_send_logical_lan(PowerPCCPU *cpu, sPAPREnvironment *spapr, 414 target_ulong opcode, target_ulong *args) 415 { 416 target_ulong reg = args[0]; 417 target_ulong *bufs = args + 1; 418 target_ulong continue_token = args[7]; 419 VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 420 VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev); 421 unsigned total_len; 422 uint8_t *lbuf, *p; 423 int i, nbufs; 424 int ret; 425 426 dprintf("H_SEND_LOGICAL_LAN(0x" TARGET_FMT_lx ", <bufs>, 0x" 427 TARGET_FMT_lx ")\n", reg, continue_token); 428 429 if (!sdev) { 430 return H_PARAMETER; 431 } 432 433 dprintf("rxbufs = %d\n", dev->rx_bufs); 434 435 if (!dev->isopen) { 436 return H_DROPPED; 437 } 438 439 if (continue_token) { 440 return H_HARDWARE; /* FIXME actually handle this */ 441 } 442 443 total_len = 0; 444 for (i = 0; i < 6; i++) { 445 dprintf(" buf desc: 0x" TARGET_FMT_lx "\n", bufs[i]); 446 if (!(bufs[i] & VLAN_BD_VALID)) { 447 break; 448 } 449 total_len += VLAN_BD_LEN(bufs[i]); 450 } 451 452 nbufs = i; 453 dprintf("h_send_logical_lan() %d buffers, total length 0x%x\n", 454 nbufs, total_len); 455 456 if (total_len == 0) { 457 return H_SUCCESS; 458 } 459 460 if (total_len > MAX_PACKET_SIZE) { 461 /* Don't let the guest force too large an allocation */ 462 return H_RESOURCE; 463 } 464 465 lbuf = alloca(total_len); 466 p = lbuf; 467 for (i = 0; i < nbufs; i++) { 468 ret = spapr_vio_dma_read(sdev, VLAN_BD_ADDR(bufs[i]), 469 p, VLAN_BD_LEN(bufs[i])); 470 if (ret < 0) { 471 return ret; 472 } 473 474 p += VLAN_BD_LEN(bufs[i]); 475 } 476 477 qemu_send_packet(qemu_get_queue(dev->nic), lbuf, total_len); 478 479 return H_SUCCESS; 480 } 481 482 static target_ulong h_multicast_ctrl(PowerPCCPU *cpu, sPAPREnvironment *spapr, 483 target_ulong opcode, target_ulong *args) 484 { 485 target_ulong reg = args[0]; 486 VIOsPAPRDevice *dev = spapr_vio_find_by_reg(spapr->vio_bus, reg); 487 488 if (!dev) { 489 return H_PARAMETER; 490 } 491 492 return H_SUCCESS; 493 } 494 495 static Property spapr_vlan_properties[] = { 496 DEFINE_SPAPR_PROPERTIES(VIOsPAPRVLANDevice, sdev), 497 DEFINE_NIC_PROPERTIES(VIOsPAPRVLANDevice, nicconf), 498 DEFINE_PROP_END_OF_LIST(), 499 }; 500 501 static void spapr_vlan_class_init(ObjectClass *klass, void *data) 502 { 503 DeviceClass *dc = DEVICE_CLASS(klass); 504 VIOsPAPRDeviceClass *k = VIO_SPAPR_DEVICE_CLASS(klass); 505 506 k->init = spapr_vlan_init; 507 k->reset = spapr_vlan_reset; 508 k->devnode = spapr_vlan_devnode; 509 k->dt_name = "l-lan"; 510 k->dt_type = "network"; 511 k->dt_compatible = "IBM,l-lan"; 512 k->signal_mask = 0x1; 513 dc->props = spapr_vlan_properties; 514 k->rtce_window_size = 0x10000000; 515 } 516 517 static const TypeInfo spapr_vlan_info = { 518 .name = TYPE_VIO_SPAPR_VLAN_DEVICE, 519 .parent = TYPE_VIO_SPAPR_DEVICE, 520 .instance_size = sizeof(VIOsPAPRVLANDevice), 521 .class_init = spapr_vlan_class_init, 522 }; 523 524 static void spapr_vlan_register_types(void) 525 { 526 spapr_register_hypercall(H_REGISTER_LOGICAL_LAN, h_register_logical_lan); 527 spapr_register_hypercall(H_FREE_LOGICAL_LAN, h_free_logical_lan); 528 spapr_register_hypercall(H_SEND_LOGICAL_LAN, h_send_logical_lan); 529 spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER, 530 h_add_logical_lan_buffer); 531 spapr_register_hypercall(H_MULTICAST_CTRL, h_multicast_ctrl); 532 type_register_static(&spapr_vlan_info); 533 } 534 535 type_init(spapr_vlan_register_types) 536