1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright 2013 Nathan Whitehorn 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/sockio.h> 35 #include <sys/endian.h> 36 #include <sys/lock.h> 37 #include <sys/mbuf.h> 38 #include <sys/module.h> 39 #include <sys/malloc.h> 40 #include <sys/mutex.h> 41 #include <sys/kernel.h> 42 #include <sys/socket.h> 43 44 #include <net/bpf.h> 45 #include <net/if.h> 46 #include <net/if_var.h> 47 #include <net/ethernet.h> 48 #include <net/if_dl.h> 49 #include <net/if_media.h> 50 #include <net/if_types.h> 51 52 #include <dev/ofw/openfirm.h> 53 #include <dev/ofw/ofw_bus.h> 54 #include <dev/ofw/ofw_bus_subr.h> 55 #include <machine/bus.h> 56 #include <machine/resource.h> 57 #include <sys/bus.h> 58 #include <sys/rman.h> 59 60 #include <powerpc/pseries/phyp-hvcall.h> 61 62 #define LLAN_MAX_RX_PACKETS 100 63 #define LLAN_MAX_TX_PACKETS 100 64 #define LLAN_RX_BUF_LEN 8*PAGE_SIZE 65 66 #define LLAN_BUFDESC_VALID (1ULL << 63) 67 #define LLAN_ADD_MULTICAST 0x1 68 #define LLAN_DEL_MULTICAST 0x2 69 #define LLAN_CLEAR_MULTICAST 0x3 70 71 struct llan_xfer { 72 struct mbuf *rx_mbuf; 73 bus_dmamap_t rx_dmamap; 74 uint64_t rx_bufdesc; 75 }; 76 77 struct llan_receive_queue_entry { /* PAPR page 539 */ 78 uint8_t control; 79 uint8_t reserved; 80 uint16_t offset; 81 uint32_t length; 82 uint64_t handle; 83 } __packed; 84 85 struct llan_softc { 86 device_t dev; 87 struct mtx io_lock; 88 89 cell_t unit; 90 uint8_t mac_address[8]; 91 92 struct ifmedia media; 93 94 int irqid; 95 struct resource *irq; 96 void *irq_cookie; 97 98 bus_dma_tag_t rx_dma_tag; 99 bus_dma_tag_t rxbuf_dma_tag; 100 bus_dma_tag_t tx_dma_tag; 101 102 bus_dmamap_t tx_dma_map; 103 104 struct llan_receive_queue_entry *rx_buf; 105 int rx_dma_slot; 106 int rx_valid_val; 107 bus_dmamap_t rx_buf_map; 108 bus_addr_t rx_buf_phys; 109 bus_size_t rx_buf_len; 110 bus_addr_t input_buf_phys; 111 bus_addr_t filter_buf_phys; 112 struct llan_xfer rx_xfer[LLAN_MAX_RX_PACKETS]; 113 114 struct ifnet *ifp; 115 }; 116 117 static int llan_probe(device_t); 118 static int llan_attach(device_t); 119 static void llan_intr(void *xsc); 120 static void llan_init(void *xsc); 121 static void llan_start(struct ifnet *ifp); 122 static int llan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data); 123 static void llan_media_status(struct ifnet *ifp, struct ifmediareq *ifmr); 124 static int llan_media_change(struct ifnet *ifp); 125 static void llan_rx_load_cb(void *xsc, bus_dma_segment_t *segs, int nsegs, 126 int err); 127 static int llan_add_rxbuf(struct llan_softc *sc, struct llan_xfer *rx); 128 static int llan_set_multicast(struct llan_softc *sc); 129 130 static devclass_t llan_devclass; 131 static device_method_t llan_methods[] = { 132 DEVMETHOD(device_probe, llan_probe), 133 DEVMETHOD(device_attach, llan_attach), 134 135 DEVMETHOD_END 136 }; 137 static driver_t llan_driver = { 138 "llan", 139 llan_methods, 140 sizeof(struct llan_softc) 141 }; 142 DRIVER_MODULE(llan, vdevice, llan_driver, llan_devclass, 0, 0); 143 144 static int 145 llan_probe(device_t dev) 146 { 147 if (!ofw_bus_is_compatible(dev,"IBM,l-lan")) 148 return (ENXIO); 149 150 device_set_desc(dev, "POWER Hypervisor Virtual Ethernet"); 151 return (0); 152 } 153 154 static int 155 llan_attach(device_t dev) 156 { 157 struct llan_softc *sc; 158 phandle_t node; 159 int error, i; 160 ssize_t len; 161 162 sc = device_get_softc(dev); 163 sc->dev = dev; 164 165 /* Get firmware properties */ 166 node = ofw_bus_get_node(dev); 167 len = OF_getprop(node, "local-mac-address", sc->mac_address, 168 sizeof(sc->mac_address)); 169 /* If local-mac-address property has only 6 bytes (ETHER_ADDR_LEN) 170 * instead of 8 (sizeof(sc->mac_address)), then its value must be 171 * shifted 2 bytes to the right. */ 172 if (len == ETHER_ADDR_LEN) { 173 bcopy(sc->mac_address, &sc->mac_address[2], len); 174 /* Zero out the first 2 bytes. */ 175 bzero(sc->mac_address, 2); 176 } 177 OF_getencprop(node, "reg", &sc->unit, sizeof(sc->unit)); 178 179 mtx_init(&sc->io_lock, "llan", NULL, MTX_DEF); 180 181 /* Setup interrupt */ 182 sc->irqid = 0; 183 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irqid, 184 RF_ACTIVE); 185 186 if (!sc->irq) { 187 device_printf(dev, "Could not allocate IRQ\n"); 188 mtx_destroy(&sc->io_lock); 189 return (ENXIO); 190 } 191 192 bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE | 193 INTR_ENTROPY, NULL, llan_intr, sc, &sc->irq_cookie); 194 195 /* Setup DMA */ 196 error = bus_dma_tag_create(bus_get_dma_tag(dev), 16, 0, 197 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL, 198 LLAN_RX_BUF_LEN, 1, BUS_SPACE_MAXSIZE_32BIT, 199 0, NULL, NULL, &sc->rx_dma_tag); 200 error = bus_dma_tag_create(bus_get_dma_tag(dev), 4, 0, 201 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL, 202 BUS_SPACE_MAXSIZE, 1, BUS_SPACE_MAXSIZE_32BIT, 203 0, NULL, NULL, &sc->rxbuf_dma_tag); 204 error = bus_dma_tag_create(bus_get_dma_tag(dev), 1, 0, 205 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 206 BUS_SPACE_MAXSIZE, 6, BUS_SPACE_MAXSIZE_32BIT, 0, 207 busdma_lock_mutex, &sc->io_lock, &sc->tx_dma_tag); 208 209 error = bus_dmamem_alloc(sc->rx_dma_tag, (void **)&sc->rx_buf, 210 BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->rx_buf_map); 211 error = bus_dmamap_load(sc->rx_dma_tag, sc->rx_buf_map, sc->rx_buf, 212 LLAN_RX_BUF_LEN, llan_rx_load_cb, sc, 0); 213 214 /* TX DMA maps */ 215 bus_dmamap_create(sc->tx_dma_tag, 0, &sc->tx_dma_map); 216 217 /* RX DMA */ 218 for (i = 0; i < LLAN_MAX_RX_PACKETS; i++) { 219 error = bus_dmamap_create(sc->rxbuf_dma_tag, 0, 220 &sc->rx_xfer[i].rx_dmamap); 221 sc->rx_xfer[i].rx_mbuf = NULL; 222 } 223 224 /* Attach to network stack */ 225 sc->ifp = if_alloc(IFT_ETHER); 226 sc->ifp->if_softc = sc; 227 228 if_initname(sc->ifp, device_get_name(dev), device_get_unit(dev)); 229 sc->ifp->if_mtu = ETHERMTU; /* XXX max-frame-size from OF? */ 230 sc->ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 231 sc->ifp->if_hwassist = 0; /* XXX: ibm,illan-options */ 232 sc->ifp->if_capabilities = 0; 233 sc->ifp->if_capenable = 0; 234 sc->ifp->if_start = llan_start; 235 sc->ifp->if_ioctl = llan_ioctl; 236 sc->ifp->if_init = llan_init; 237 238 ifmedia_init(&sc->media, IFM_IMASK, llan_media_change, 239 llan_media_status); 240 ifmedia_add(&sc->media, IFM_ETHER | IFM_AUTO, 0, NULL); 241 ifmedia_set(&sc->media, IFM_ETHER | IFM_AUTO); 242 243 IFQ_SET_MAXLEN(&sc->ifp->if_snd, LLAN_MAX_TX_PACKETS); 244 sc->ifp->if_snd.ifq_drv_maxlen = LLAN_MAX_TX_PACKETS; 245 IFQ_SET_READY(&sc->ifp->if_snd); 246 247 ether_ifattach(sc->ifp, &sc->mac_address[2]); 248 249 /* We don't have link state reporting, so make it always up */ 250 if_link_state_change(sc->ifp, LINK_STATE_UP); 251 252 return (0); 253 } 254 255 static int 256 llan_media_change(struct ifnet *ifp) 257 { 258 struct llan_softc *sc = ifp->if_softc; 259 260 if (IFM_TYPE(sc->media.ifm_media) != IFM_ETHER) 261 return (EINVAL); 262 263 if (IFM_SUBTYPE(sc->media.ifm_media) != IFM_AUTO) 264 return (EINVAL); 265 266 return (0); 267 } 268 269 static void 270 llan_media_status(struct ifnet *ifp, struct ifmediareq *ifmr) 271 { 272 273 ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE | IFM_UNKNOWN | IFM_FDX; 274 ifmr->ifm_active = IFM_ETHER; 275 } 276 277 static void 278 llan_rx_load_cb(void *xsc, bus_dma_segment_t *segs, int nsegs, int err) 279 { 280 struct llan_softc *sc = xsc; 281 282 sc->rx_buf_phys = segs[0].ds_addr; 283 sc->rx_buf_len = segs[0].ds_len - 2*PAGE_SIZE; 284 sc->input_buf_phys = segs[0].ds_addr + segs[0].ds_len - PAGE_SIZE; 285 sc->filter_buf_phys = segs[0].ds_addr + segs[0].ds_len - 2*PAGE_SIZE; 286 } 287 288 static void 289 llan_init(void *xsc) 290 { 291 struct llan_softc *sc = xsc; 292 uint64_t rx_buf_desc; 293 uint64_t macaddr; 294 int err, i; 295 296 mtx_lock(&sc->io_lock); 297 298 phyp_hcall(H_FREE_LOGICAL_LAN, sc->unit); 299 300 /* Create buffers (page 539) */ 301 sc->rx_dma_slot = 0; 302 sc->rx_valid_val = 1; 303 304 rx_buf_desc = LLAN_BUFDESC_VALID; 305 rx_buf_desc |= (sc->rx_buf_len << 32); 306 rx_buf_desc |= sc->rx_buf_phys; 307 memcpy(&macaddr, sc->mac_address, 8); 308 err = phyp_hcall(H_REGISTER_LOGICAL_LAN, sc->unit, sc->input_buf_phys, 309 rx_buf_desc, sc->filter_buf_phys, macaddr); 310 311 for (i = 0; i < LLAN_MAX_RX_PACKETS; i++) 312 llan_add_rxbuf(sc, &sc->rx_xfer[i]); 313 314 phyp_hcall(H_VIO_SIGNAL, sc->unit, 1); /* Enable interrupts */ 315 316 /* Tell stack we're up */ 317 sc->ifp->if_drv_flags |= IFF_DRV_RUNNING; 318 sc->ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 319 320 mtx_unlock(&sc->io_lock); 321 322 /* Check for pending receives scheduled before interrupt enable */ 323 llan_intr(sc); 324 } 325 326 static int 327 llan_add_rxbuf(struct llan_softc *sc, struct llan_xfer *rx) 328 { 329 struct mbuf *m; 330 bus_dma_segment_t segs[1]; 331 int error, nsegs; 332 333 mtx_assert(&sc->io_lock, MA_OWNED); 334 335 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); 336 if (m == NULL) 337 return (ENOBUFS); 338 339 m->m_len = m->m_pkthdr.len = m->m_ext.ext_size; 340 if (rx->rx_mbuf != NULL) { 341 bus_dmamap_sync(sc->rxbuf_dma_tag, rx->rx_dmamap, 342 BUS_DMASYNC_POSTREAD); 343 bus_dmamap_unload(sc->rxbuf_dma_tag, rx->rx_dmamap); 344 } 345 346 /* Save pointer to buffer structure */ 347 m_copyback(m, 0, 8, (void *)&rx); 348 349 error = bus_dmamap_load_mbuf_sg(sc->rxbuf_dma_tag, rx->rx_dmamap, m, 350 segs, &nsegs, BUS_DMA_NOWAIT); 351 if (error != 0) { 352 device_printf(sc->dev, 353 "cannot load RX DMA map %p, error = %d\n", rx, error); 354 m_freem(m); 355 return (error); 356 } 357 358 /* If nsegs is wrong then the stack is corrupt. */ 359 KASSERT(nsegs == 1, 360 ("%s: too many DMA segments (%d)", __func__, nsegs)); 361 rx->rx_mbuf = m; 362 363 bus_dmamap_sync(sc->rxbuf_dma_tag, rx->rx_dmamap, BUS_DMASYNC_PREREAD); 364 365 rx->rx_bufdesc = LLAN_BUFDESC_VALID; 366 rx->rx_bufdesc |= (((uint64_t)segs[0].ds_len) << 32); 367 rx->rx_bufdesc |= segs[0].ds_addr; 368 error = phyp_hcall(H_ADD_LOGICAL_LAN_BUFFER, sc->unit, rx->rx_bufdesc); 369 if (error != 0) { 370 m_freem(m); 371 rx->rx_mbuf = NULL; 372 return (ENOBUFS); 373 } 374 375 return (0); 376 } 377 378 static void 379 llan_intr(void *xsc) 380 { 381 struct llan_softc *sc = xsc; 382 struct llan_xfer *rx; 383 struct mbuf *m; 384 385 mtx_lock(&sc->io_lock); 386 restart: 387 phyp_hcall(H_VIO_SIGNAL, sc->unit, 0); 388 389 while ((sc->rx_buf[sc->rx_dma_slot].control >> 7) == sc->rx_valid_val) { 390 rx = (struct llan_xfer *)sc->rx_buf[sc->rx_dma_slot].handle; 391 m = rx->rx_mbuf; 392 m_adj(m, sc->rx_buf[sc->rx_dma_slot].offset - 8); 393 m->m_len = sc->rx_buf[sc->rx_dma_slot].length; 394 395 /* llan_add_rxbuf does DMA sync and unload as well as requeue */ 396 if (llan_add_rxbuf(sc, rx) != 0) { 397 if_inc_counter(sc->ifp, IFCOUNTER_IERRORS, 1); 398 continue; 399 } 400 401 if_inc_counter(sc->ifp, IFCOUNTER_IPACKETS, 1); 402 m_adj(m, sc->rx_buf[sc->rx_dma_slot].offset); 403 m->m_len = sc->rx_buf[sc->rx_dma_slot].length; 404 m->m_pkthdr.rcvif = sc->ifp; 405 m->m_pkthdr.len = m->m_len; 406 sc->rx_dma_slot++; 407 408 if (sc->rx_dma_slot >= sc->rx_buf_len/sizeof(sc->rx_buf[0])) { 409 sc->rx_dma_slot = 0; 410 sc->rx_valid_val = !sc->rx_valid_val; 411 } 412 413 mtx_unlock(&sc->io_lock); 414 (*sc->ifp->if_input)(sc->ifp, m); 415 mtx_lock(&sc->io_lock); 416 } 417 418 phyp_hcall(H_VIO_SIGNAL, sc->unit, 1); 419 420 /* 421 * H_VIO_SIGNAL enables interrupts for future packets only. 422 * Make sure none were queued between the end of the loop and the 423 * enable interrupts call. 424 */ 425 if ((sc->rx_buf[sc->rx_dma_slot].control >> 7) == sc->rx_valid_val) 426 goto restart; 427 428 mtx_unlock(&sc->io_lock); 429 } 430 431 static void 432 llan_send_packet(void *xsc, bus_dma_segment_t *segs, int nsegs, 433 bus_size_t mapsize, int error) 434 { 435 struct llan_softc *sc = xsc; 436 uint64_t bufdescs[6]; 437 int i, err; 438 439 bzero(bufdescs, sizeof(bufdescs)); 440 441 for (i = 0; i < nsegs; i++) { 442 bufdescs[i] = LLAN_BUFDESC_VALID; 443 bufdescs[i] |= (((uint64_t)segs[i].ds_len) << 32); 444 bufdescs[i] |= segs[i].ds_addr; 445 } 446 447 err = phyp_hcall(H_SEND_LOGICAL_LAN, sc->unit, bufdescs[0], 448 bufdescs[1], bufdescs[2], bufdescs[3], bufdescs[4], bufdescs[5], 0); 449 /* 450 * The hypercall returning implies completion -- or that the call will 451 * not complete. In principle, we should try a few times if we get back 452 * H_BUSY based on the continuation token in R4. For now, just drop 453 * the packet in such cases. 454 */ 455 if (err == H_SUCCESS) 456 if_inc_counter(sc->ifp, IFCOUNTER_OPACKETS, 1); 457 else 458 if_inc_counter(sc->ifp, IFCOUNTER_OERRORS, 1); 459 } 460 461 static void 462 llan_start_locked(struct ifnet *ifp) 463 { 464 struct llan_softc *sc = ifp->if_softc; 465 bus_addr_t first; 466 int nsegs; 467 struct mbuf *mb_head, *m; 468 469 mtx_assert(&sc->io_lock, MA_OWNED); 470 first = 0; 471 472 if ((ifp->if_drv_flags & (IFF_DRV_RUNNING | IFF_DRV_OACTIVE)) != 473 IFF_DRV_RUNNING) 474 return; 475 476 while (!IFQ_DRV_IS_EMPTY(&ifp->if_snd)) { 477 IFQ_DRV_DEQUEUE(&ifp->if_snd, mb_head); 478 479 if (mb_head == NULL) 480 break; 481 482 BPF_MTAP(ifp, mb_head); 483 484 for (m = mb_head, nsegs = 0; m != NULL; m = m->m_next) 485 nsegs++; 486 if (nsegs > 6) { 487 m = m_collapse(mb_head, M_NOWAIT, 6); 488 if (m == NULL) { 489 m_freem(mb_head); 490 continue; 491 } 492 } 493 494 bus_dmamap_load_mbuf(sc->tx_dma_tag, sc->tx_dma_map, 495 mb_head, llan_send_packet, sc, 0); 496 bus_dmamap_unload(sc->tx_dma_tag, sc->tx_dma_map); 497 m_freem(mb_head); 498 } 499 } 500 501 static void 502 llan_start(struct ifnet *ifp) 503 { 504 struct llan_softc *sc = ifp->if_softc; 505 506 mtx_lock(&sc->io_lock); 507 llan_start_locked(ifp); 508 mtx_unlock(&sc->io_lock); 509 } 510 511 static u_int 512 llan_set_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt) 513 { 514 struct llan_softc *sc = arg; 515 uint64_t macaddr = 0; 516 517 memcpy((uint8_t *)&macaddr + 2, LLADDR(sdl), 6); 518 phyp_hcall(H_MULTICAST_CTRL, sc->unit, LLAN_ADD_MULTICAST, macaddr); 519 520 return (1); 521 } 522 523 static int 524 llan_set_multicast(struct llan_softc *sc) 525 { 526 struct ifnet *ifp = sc->ifp; 527 528 mtx_assert(&sc->io_lock, MA_OWNED); 529 530 phyp_hcall(H_MULTICAST_CTRL, sc->unit, LLAN_CLEAR_MULTICAST, 0); 531 532 if_foreach_llmaddr(ifp, llan_set_maddr, sc); 533 534 return (0); 535 } 536 537 static int 538 llan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 539 { 540 int err = 0; 541 struct llan_softc *sc = ifp->if_softc; 542 543 switch (cmd) { 544 case SIOCADDMULTI: 545 case SIOCDELMULTI: 546 mtx_lock(&sc->io_lock); 547 if ((sc->ifp->if_drv_flags & IFF_DRV_RUNNING) != 0) 548 llan_set_multicast(sc); 549 mtx_unlock(&sc->io_lock); 550 break; 551 case SIOCGIFMEDIA: 552 case SIOCSIFMEDIA: 553 err = ifmedia_ioctl(ifp, (struct ifreq *)data, &sc->media, cmd); 554 break; 555 case SIOCSIFFLAGS: 556 default: 557 err = ether_ioctl(ifp, cmd, data); 558 break; 559 } 560 561 return (err); 562 } 563