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
llan_probe(device_t dev)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
llan_attach(device_t dev)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
llan_media_change(struct ifnet * ifp)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
llan_media_status(struct ifnet * ifp,struct ifmediareq * ifmr)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
llan_rx_load_cb(void * xsc,bus_dma_segment_t * segs,int nsegs,int err)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
llan_init(void * xsc)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
llan_add_rxbuf(struct llan_softc * sc,struct llan_xfer * rx)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
llan_intr(void * xsc)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
llan_send_packet(void * xsc,bus_dma_segment_t * segs,int nsegs,bus_size_t mapsize,int error)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
llan_start_locked(struct ifnet * ifp)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
llan_start(struct ifnet * ifp)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
llan_set_maddr(void * arg,struct sockaddr_dl * sdl,u_int cnt)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
llan_set_multicast(struct llan_softc * sc)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
llan_ioctl(struct ifnet * ifp,u_long cmd,caddr_t data)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