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