1/*	$NetBSD: lance.c,v 1.34 2005/12/24 20:27:30 perry Exp $	*/
2
3/*-
4 * SPDX-License-Identifier: BSD-2-Clause-NetBSD
5 *
6 * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
7 * All rights reserved.
8 *
9 * This code is derived from software contributed to The NetBSD Foundation
10 * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
11 * Simulation Facility, NASA Ames Research Center.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 *    notice, this list of conditions and the following disclaimer.
18 * 2. Redistributions in binary form must reproduce the above copyright
19 *    notice, this list of conditions and the following disclaimer in the
20 *    documentation and/or other materials provided with the distribution.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35/*-
36 * Copyright (c) 1992, 1993
37 *	The Regents of the University of California.  All rights reserved.
38 *
39 * This code is derived from software contributed to Berkeley by
40 * Ralph Campbell and Rick Macklem.
41 *
42 * Redistribution and use in source and binary forms, with or without
43 * modification, are permitted provided that the following conditions
44 * are met:
45 * 1. Redistributions of source code must retain the above copyright
46 *    notice, this list of conditions and the following disclaimer.
47 * 2. Redistributions in binary form must reproduce the above copyright
48 *    notice, this list of conditions and the following disclaimer in the
49 *    documentation and/or other materials provided with the distribution.
50 * 3. Neither the name of the University nor the names of its contributors
51 *    may be used to endorse or promote products derived from this software
52 *    without specific prior written permission.
53 *
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 * SUCH DAMAGE.
65 *
66 *	@(#)if_le.c	8.2 (Berkeley) 11/16/93
67 */
68
69#include <sys/cdefs.h>
70__FBSDID("$FreeBSD: releng/12.0/sys/dev/le/lance.c 333813 2018-05-18 20:13:34Z mmacy $");
71
72#include <sys/param.h>
73#include <sys/bus.h>
74#include <sys/endian.h>
75#include <sys/lock.h>
76#include <sys/kernel.h>
77#include <sys/malloc.h>
78#include <sys/mbuf.h>
79#include <sys/mutex.h>
80#include <sys/socket.h>
81#include <sys/sockio.h>
82
83#include <net/ethernet.h>
84#include <net/if.h>
85#include <net/if_var.h>
86#include <net/if_arp.h>
87#include <net/if_dl.h>
88#include <net/if_media.h>
89#include <net/if_types.h>
90#include <net/if_vlan_var.h>
91
92#include <machine/bus.h>
93
94#include <dev/le/lancereg.h>
95#include <dev/le/lancevar.h>
96
97devclass_t le_devclass;
98
99static void lance_start(struct ifnet *);
100static void lance_stop(struct lance_softc *);
101static void lance_init(void *);
102static void lance_watchdog(void *s);
103static int lance_mediachange(struct ifnet *);
104static void lance_mediastatus(struct ifnet *, struct ifmediareq *);
105static int lance_ioctl(struct ifnet *, u_long, caddr_t);
106
107int
108lance_config(struct lance_softc *sc, const char* name, int unit)
109{
110	struct ifnet *ifp;
111	int i, nbuf;
112
113	if (LE_LOCK_INITIALIZED(sc) == 0)
114		return (ENXIO);
115
116	ifp = sc->sc_ifp = if_alloc(IFT_ETHER);
117	if (ifp == NULL)
118		return (ENOSPC);
119
120	callout_init_mtx(&sc->sc_wdog_ch, &sc->sc_mtx, 0);
121
122	/* Initialize ifnet structure. */
123	ifp->if_softc = sc;
124	if_initname(ifp, name, unit);
125	ifp->if_start = lance_start;
126	ifp->if_ioctl = lance_ioctl;
127	ifp->if_init = lance_init;
128	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
129#ifdef LANCE_REVC_BUG
130	ifp->if_flags &= ~IFF_MULTICAST;
131#endif
132	ifp->if_baudrate = IF_Mbps(10);
133	IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
134	ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
135	IFQ_SET_READY(&ifp->if_snd);
136
137	/* Initialize ifmedia structures. */
138	ifmedia_init(&sc->sc_media, 0, lance_mediachange, lance_mediastatus);
139	if (sc->sc_supmedia != NULL) {
140		for (i = 0; i < sc->sc_nsupmedia; i++)
141			ifmedia_add(&sc->sc_media, sc->sc_supmedia[i], 0, NULL);
142		ifmedia_set(&sc->sc_media, sc->sc_defaultmedia);
143	} else {
144		ifmedia_add(&sc->sc_media,
145		    IFM_MAKEWORD(IFM_ETHER, IFM_MANUAL, 0, 0), 0, NULL);
146		ifmedia_set(&sc->sc_media,
147		    IFM_MAKEWORD(IFM_ETHER, IFM_MANUAL, 0, 0));
148	}
149
150	switch (sc->sc_memsize) {
151	case 8192:
152		sc->sc_nrbuf = 4;
153		sc->sc_ntbuf = 1;
154		break;
155	case 16384:
156		sc->sc_nrbuf = 8;
157		sc->sc_ntbuf = 2;
158		break;
159	case 32768:
160		sc->sc_nrbuf = 16;
161		sc->sc_ntbuf = 4;
162		break;
163	case 65536:
164		sc->sc_nrbuf = 32;
165		sc->sc_ntbuf = 8;
166		break;
167	case 131072:
168		sc->sc_nrbuf = 64;
169		sc->sc_ntbuf = 16;
170		break;
171	case 262144:
172		sc->sc_nrbuf = 128;
173		sc->sc_ntbuf = 32;
174		break;
175	default:
176		/* weird memory size; cope with it */
177		nbuf = sc->sc_memsize / LEBLEN;
178		sc->sc_ntbuf = nbuf / 5;
179		sc->sc_nrbuf = nbuf - sc->sc_ntbuf;
180	}
181
182	if_printf(ifp, "%d receive buffers, %d transmit buffers\n",
183	    sc->sc_nrbuf, sc->sc_ntbuf);
184
185	/* Make sure the chip is stopped. */
186	LE_LOCK(sc);
187	lance_stop(sc);
188	LE_UNLOCK(sc);
189
190	return (0);
191}
192
193void
194lance_attach(struct lance_softc *sc)
195{
196	struct ifnet *ifp = sc->sc_ifp;
197
198	/* Attach the interface. */
199	ether_ifattach(ifp, sc->sc_enaddr);
200
201	/* Claim 802.1q capability. */
202	ifp->if_hdrlen = sizeof(struct ether_vlan_header);
203	ifp->if_capabilities |= IFCAP_VLAN_MTU;
204	ifp->if_capenable |= IFCAP_VLAN_MTU;
205}
206
207void
208lance_detach(struct lance_softc *sc)
209{
210	struct ifnet *ifp = sc->sc_ifp;
211
212	LE_LOCK(sc);
213	lance_stop(sc);
214	LE_UNLOCK(sc);
215	callout_drain(&sc->sc_wdog_ch);
216	ether_ifdetach(ifp);
217	if_free(ifp);
218}
219
220void
221lance_suspend(struct lance_softc *sc)
222{
223
224	LE_LOCK(sc);
225	lance_stop(sc);
226	LE_UNLOCK(sc);
227}
228
229void
230lance_resume(struct lance_softc *sc)
231{
232
233	LE_LOCK(sc);
234	if (sc->sc_ifp->if_flags & IFF_UP)
235		lance_init_locked(sc);
236	LE_UNLOCK(sc);
237}
238
239static void
240lance_start(struct ifnet *ifp)
241{
242	struct lance_softc *sc = ifp->if_softc;
243
244	LE_LOCK(sc);
245	(*sc->sc_start_locked)(sc);
246	LE_UNLOCK(sc);
247}
248
249static void
250lance_stop(struct lance_softc *sc)
251{
252	struct ifnet *ifp = sc->sc_ifp;
253
254	LE_LOCK_ASSERT(sc, MA_OWNED);
255
256	/*
257	 * Mark the interface down and cancel the watchdog timer.
258	 */
259	ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
260	callout_stop(&sc->sc_wdog_ch);
261	sc->sc_wdog_timer = 0;
262
263	(*sc->sc_wrcsr)(sc, LE_CSR0, LE_C0_STOP);
264}
265
266static void
267lance_init(void *xsc)
268{
269	struct lance_softc *sc = (struct lance_softc *)xsc;
270
271	LE_LOCK(sc);
272	lance_init_locked(sc);
273	LE_UNLOCK(sc);
274}
275
276/*
277 * Initialization of interface; set up initialization block
278 * and transmit/receive descriptor rings.
279 */
280void
281lance_init_locked(struct lance_softc *sc)
282{
283	struct ifnet *ifp = sc->sc_ifp;
284	u_long a;
285	int timo;
286
287	LE_LOCK_ASSERT(sc, MA_OWNED);
288
289	(*sc->sc_wrcsr)(sc, LE_CSR0, LE_C0_STOP);
290	DELAY(100);
291
292	/* Newer LANCE chips have a reset register. */
293	if (sc->sc_hwreset)
294		(*sc->sc_hwreset)(sc);
295
296	/* Set the correct byte swapping mode, etc. */
297	(*sc->sc_wrcsr)(sc, LE_CSR3, sc->sc_conf3);
298
299	/* Set the current media. This may require the chip to be stopped. */
300	if (sc->sc_mediachange)
301		(void)(*sc->sc_mediachange)(sc);
302
303	/*
304	 * Update our private copy of the Ethernet address.
305	 * We NEED the copy so we can ensure its alignment!
306	 */
307	memcpy(sc->sc_enaddr, IF_LLADDR(ifp), ETHER_ADDR_LEN);
308
309	/* Set up LANCE init block. */
310	(*sc->sc_meminit)(sc);
311
312	/* Give LANCE the physical address of its init block. */
313	a = sc->sc_addr + LE_INITADDR(sc);
314	(*sc->sc_wrcsr)(sc, LE_CSR1, a & 0xffff);
315	(*sc->sc_wrcsr)(sc, LE_CSR2, a >> 16);
316
317	/* Try to initialize the LANCE. */
318	DELAY(100);
319	(*sc->sc_wrcsr)(sc, LE_CSR0, LE_C0_INIT);
320
321	/* Wait for initialization to finish. */
322	for (timo = 100000; timo; timo--)
323		if ((*sc->sc_rdcsr)(sc, LE_CSR0) & LE_C0_IDON)
324			break;
325
326	if ((*sc->sc_rdcsr)(sc, LE_CSR0) & LE_C0_IDON) {
327		/* Start the LANCE. */
328		(*sc->sc_wrcsr)(sc, LE_CSR0, LE_C0_INEA | LE_C0_STRT);
329		ifp->if_drv_flags |= IFF_DRV_RUNNING;
330		ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
331		sc->sc_wdog_timer = 0;
332		callout_reset(&sc->sc_wdog_ch, hz, lance_watchdog, sc);
333		(*sc->sc_start_locked)(sc);
334	} else
335		if_printf(ifp, "controller failed to initialize\n");
336
337	if (sc->sc_hwinit)
338		(*sc->sc_hwinit)(sc);
339}
340
341/*
342 * Routine to copy from mbuf chain to transmit buffer in
343 * network buffer memory.
344 */
345int
346lance_put(struct lance_softc *sc, int boff, struct mbuf *m)
347{
348	struct mbuf *n;
349	int len, tlen = 0;
350
351	LE_LOCK_ASSERT(sc, MA_OWNED);
352
353	for (; m; m = n) {
354		len = m->m_len;
355		if (len == 0) {
356			n = m_free(m);
357			m = NULL;
358			continue;
359		}
360		(*sc->sc_copytobuf)(sc, mtod(m, caddr_t), boff, len);
361		boff += len;
362		tlen += len;
363		n = m_free(m);
364		m = NULL;
365	}
366	if (tlen < LEMINSIZE) {
367		(*sc->sc_zerobuf)(sc, boff, LEMINSIZE - tlen);
368		tlen = LEMINSIZE;
369	}
370	return (tlen);
371}
372
373/*
374 * Pull data off an interface.
375 * Len is length of data, with local net header stripped.
376 * We copy the data into mbufs.  When full cluster sized units are present
377 * we copy into clusters.
378 */
379struct mbuf *
380lance_get(struct lance_softc *sc, int boff, int totlen)
381{
382	struct ifnet *ifp = sc->sc_ifp;
383	struct mbuf *m, *m0, *newm;
384	caddr_t newdata;
385	int len;
386
387	if (totlen <= ETHER_HDR_LEN || totlen > LEBLEN - ETHER_CRC_LEN) {
388#ifdef LEDEBUG
389		if_printf(ifp, "invalid packet size %d; dropping\n", totlen);
390#endif
391		return (NULL);
392	}
393
394	MGETHDR(m0, M_NOWAIT, MT_DATA);
395	if (m0 == NULL)
396		return (NULL);
397	m0->m_pkthdr.rcvif = ifp;
398	m0->m_pkthdr.len = totlen;
399	len = MHLEN;
400	m = m0;
401
402	while (totlen > 0) {
403		if (totlen >= MINCLSIZE) {
404			if (!(MCLGET(m, M_NOWAIT)))
405				goto bad;
406			len = MCLBYTES;
407		}
408
409		if (m == m0) {
410			newdata = (caddr_t)
411			    ALIGN(m->m_data + ETHER_HDR_LEN) - ETHER_HDR_LEN;
412			len -= newdata - m->m_data;
413			m->m_data = newdata;
414		}
415
416		m->m_len = len = min(totlen, len);
417		(*sc->sc_copyfrombuf)(sc, mtod(m, caddr_t), boff, len);
418		boff += len;
419
420		totlen -= len;
421		if (totlen > 0) {
422			MGET(newm, M_NOWAIT, MT_DATA);
423			if (newm == NULL)
424				goto bad;
425			len = MLEN;
426			m = m->m_next = newm;
427		}
428	}
429
430	return (m0);
431
432 bad:
433	m_freem(m0);
434	return (NULL);
435}
436
437static void
438lance_watchdog(void *xsc)
439{
440	struct lance_softc *sc = (struct lance_softc *)xsc;
441	struct ifnet *ifp = sc->sc_ifp;
442
443	LE_LOCK_ASSERT(sc, MA_OWNED);
444
445	if (sc->sc_wdog_timer == 0 || --sc->sc_wdog_timer != 0) {
446		callout_reset(&sc->sc_wdog_ch, hz, lance_watchdog, sc);
447		return;
448	}
449
450	if_printf(ifp, "device timeout\n");
451	if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
452	lance_init_locked(sc);
453}
454
455static int
456lance_mediachange(struct ifnet *ifp)
457{
458	struct lance_softc *sc = ifp->if_softc;
459
460	if (sc->sc_mediachange) {
461		/*
462		 * For setting the port in LE_CSR15 the PCnet chips must
463		 * be powered down or stopped and unlike documented may
464		 * not take effect without an initialization. So don't
465		 * invoke (*sc_mediachange) directly here but go through
466		 * lance_init_locked().
467		 */
468		LE_LOCK(sc);
469		lance_stop(sc);
470		lance_init_locked(sc);
471		if (!IFQ_DRV_IS_EMPTY(&ifp->if_snd))
472			(*sc->sc_start_locked)(sc);
473		LE_UNLOCK(sc);
474	}
475	return (0);
476}
477
478static void
479lance_mediastatus(struct ifnet *ifp, struct ifmediareq *ifmr)
480{
481	struct lance_softc *sc = ifp->if_softc;
482
483	LE_LOCK(sc);
484	if (!(ifp->if_flags & IFF_UP)) {
485		LE_UNLOCK(sc);
486		return;
487	}
488
489	ifmr->ifm_status = IFM_AVALID;
490	if (sc->sc_flags & LE_CARRIER)
491		ifmr->ifm_status |= IFM_ACTIVE;
492
493	if (sc->sc_mediastatus)
494		(*sc->sc_mediastatus)(sc, ifmr);
495	LE_UNLOCK(sc);
496}
497
498/*
499 * Process an ioctl request.
500 */
501static int
502lance_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
503{
504	struct lance_softc *sc = ifp->if_softc;
505	struct ifreq *ifr = (struct ifreq *)data;
506	int error = 0;
507
508	switch (cmd) {
509	case SIOCSIFFLAGS:
510		LE_LOCK(sc);
511		if (ifp->if_flags & IFF_PROMISC) {
512			if (!(sc->sc_flags & LE_PROMISC)) {
513				sc->sc_flags |= LE_PROMISC;
514				lance_init_locked(sc);
515			}
516		} else if (sc->sc_flags & LE_PROMISC) {
517			sc->sc_flags &= ~LE_PROMISC;
518			lance_init_locked(sc);
519		}
520
521		if ((ifp->if_flags & IFF_ALLMULTI) &&
522		    !(sc->sc_flags & LE_ALLMULTI)) {
523			sc->sc_flags |= LE_ALLMULTI;
524			lance_init_locked(sc);
525		} else if (!(ifp->if_flags & IFF_ALLMULTI) &&
526		    (sc->sc_flags & LE_ALLMULTI)) {
527			sc->sc_flags &= ~LE_ALLMULTI;
528			lance_init_locked(sc);
529		}
530
531		if (!(ifp->if_flags & IFF_UP) &&
532		    ifp->if_drv_flags & IFF_DRV_RUNNING) {
533			/*
534			 * If interface is marked down and it is running, then
535			 * stop it.
536			 */
537			lance_stop(sc);
538		} else if (ifp->if_flags & IFF_UP &&
539		    !(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
540			/*
541			 * If interface is marked up and it is stopped, then
542			 * start it.
543			 */
544			lance_init_locked(sc);
545		}
546#ifdef LEDEBUG
547		if (ifp->if_flags & IFF_DEBUG)
548			sc->sc_flags |= LE_DEBUG;
549		else
550			sc->sc_flags &= ~LE_DEBUG;
551#endif
552		LE_UNLOCK(sc);
553		break;
554
555	case SIOCADDMULTI:
556	case SIOCDELMULTI:
557		/*
558		 * Multicast list has changed; set the hardware filter
559		 * accordingly.
560		 */
561		LE_LOCK(sc);
562		if (ifp->if_drv_flags & IFF_DRV_RUNNING)
563			lance_init_locked(sc);
564		LE_UNLOCK(sc);
565		break;
566
567	case SIOCGIFMEDIA:
568	case SIOCSIFMEDIA:
569		error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, cmd);
570		break;
571
572	default:
573		error = ether_ioctl(ifp, cmd, data);
574		break;
575	}
576
577	return (error);
578}
579
580/*
581 * Set up the logical address filter.
582 */
583void
584lance_setladrf(struct lance_softc *sc, uint16_t *af)
585{
586	struct ifnet *ifp = sc->sc_ifp;
587	struct ifmultiaddr *ifma;
588	uint32_t crc;
589
590	/*
591	 * Set up multicast address filter by passing all multicast addresses
592	 * through a crc generator, and then using the high order 6 bits as an
593	 * index into the 64 bit logical address filter.  The high order bit
594	 * selects the word, while the rest of the bits select the bit within
595	 * the word.
596	 */
597
598	if (ifp->if_flags & IFF_PROMISC || sc->sc_flags & LE_ALLMULTI) {
599		af[0] = af[1] = af[2] = af[3] = 0xffff;
600		return;
601	}
602
603	af[0] = af[1] = af[2] = af[3] = 0x0000;
604	if_maddr_rlock(ifp);
605	TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
606		if (ifma->ifma_addr->sa_family != AF_LINK)
607			continue;
608
609		crc = ether_crc32_le(LLADDR((struct sockaddr_dl *)
610		    ifma->ifma_addr), ETHER_ADDR_LEN);
611
612		/* Just want the 6 most significant bits. */
613		crc >>= 26;
614
615		/* Set the corresponding bit in the filter. */
616		af[crc >> 4] |= LE_HTOLE16(1 << (crc & 0xf));
617	}
618	if_maddr_runlock(ifp);
619}
620
621/*
622 * Routines for accessing the transmit and receive buffers.
623 * The various CPU and adapter configurations supported by this
624 * driver require three different access methods for buffers
625 * and descriptors:
626 *	(1) contig (contiguous data; no padding),
627 *	(2) gap2 (two bytes of data followed by two bytes of padding),
628 *	(3) gap16 (16 bytes of data followed by 16 bytes of padding).
629 */
630
631/*
632 * contig: contiguous data with no padding.
633 *
634 * Buffers may have any alignment.
635 */
636
637void
638lance_copytobuf_contig(struct lance_softc *sc, void *from, int boff, int len)
639{
640	volatile caddr_t buf = sc->sc_mem;
641
642	/*
643	 * Just call memcpy() to do the work.
644	 */
645	memcpy(buf + boff, from, len);
646}
647
648void
649lance_copyfrombuf_contig(struct lance_softc *sc, void *to, int boff, int len)
650{
651	volatile caddr_t buf = sc->sc_mem;
652
653	/*
654	 * Just call memcpy() to do the work.
655	 */
656	memcpy(to, buf + boff, len);
657}
658
659void
660lance_zerobuf_contig(struct lance_softc *sc, int boff, int len)
661{
662	volatile caddr_t buf = sc->sc_mem;
663
664	/*
665	 * Just let memset() do the work
666	 */
667	memset(buf + boff, 0, len);
668}
669
670#if 0
671/*
672 * Examples only; duplicate these and tweak (if necessary) in
673 * machine-specific front-ends.
674 */
675
676/*
677 * gap2: two bytes of data followed by two bytes of pad.
678 *
679 * Buffers must be 4-byte aligned.  The code doesn't worry about
680 * doing an extra byte.
681 */
682
683static void
684lance_copytobuf_gap2(struct lance_softc *sc, void *fromv, int boff, int len)
685{
686	volatile caddr_t buf = sc->sc_mem;
687	caddr_t from = fromv;
688	volatile uint16_t *bptr;
689
690	if (boff & 0x1) {
691		/* Handle unaligned first byte. */
692		bptr = ((volatile uint16_t *)buf) + (boff - 1);
693		*bptr = (*from++ << 8) | (*bptr & 0xff);
694		bptr += 2;
695		len--;
696	} else
697		bptr = ((volatile uint16_t *)buf) + boff;
698	while (len > 1) {
699		*bptr = (from[1] << 8) | (from[0] & 0xff);
700		bptr += 2;
701		from += 2;
702		len -= 2;
703	}
704	if (len == 1)
705		*bptr = (uint16_t)*from;
706}
707
708static void
709lance_copyfrombuf_gap2(struct lance_softc *sc, void *tov, int boff, int len)
710{
711	volatile caddr_t buf = sc->sc_mem;
712	caddr_t to = tov;
713	volatile uint16_t *bptr;
714	uint16_t tmp;
715
716	if (boff & 0x1) {
717		/* Handle unaligned first byte. */
718		bptr = ((volatile uint16_t *)buf) + (boff - 1);
719		*to++ = (*bptr >> 8) & 0xff;
720		bptr += 2;
721		len--;
722	} else
723		bptr = ((volatile uint16_t *)buf) + boff;
724	while (len > 1) {
725		tmp = *bptr;
726		*to++ = tmp & 0xff;
727		*to++ = (tmp >> 8) & 0xff;
728		bptr += 2;
729		len -= 2;
730	}
731	if (len == 1)
732		*to = *bptr & 0xff;
733}
734
735static void
736lance_zerobuf_gap2(struct lance_softc *sc, int boff, int len)
737{
738	volatile caddr_t buf = sc->sc_mem;
739	volatile uint16_t *bptr;
740
741	if ((unsigned)boff & 0x1) {
742		bptr = ((volatile uint16_t *)buf) + (boff - 1);
743		*bptr &= 0xff;
744		bptr += 2;
745		len--;
746	} else
747		bptr = ((volatile uint16_t *)buf) + boff;
748	while (len > 0) {
749		*bptr = 0;
750		bptr += 2;
751		len -= 2;
752	}
753}
754
755/*
756 * gap16: 16 bytes of data followed by 16 bytes of pad.
757 *
758 * Buffers must be 32-byte aligned.
759 */
760
761static void
762lance_copytobuf_gap16(struct lance_softc *sc, void *fromv, int boff, int len)
763{
764	volatile caddr_t buf = sc->sc_mem;
765	caddr_t bptr, from = fromv;
766	int xfer;
767
768	bptr = buf + ((boff << 1) & ~0x1f);
769	boff &= 0xf;
770	xfer = min(len, 16 - boff);
771	while (len > 0) {
772		memcpy(bptr + boff, from, xfer);
773		from += xfer;
774		bptr += 32;
775		boff = 0;
776		len -= xfer;
777		xfer = min(len, 16);
778	}
779}
780
781static void
782lance_copyfrombuf_gap16(struct lance_softc *sc, void *tov, int boff, int len)
783{
784	volatile caddr_t buf = sc->sc_mem;
785	caddr_t bptr, to = tov;
786	int xfer;
787
788	bptr = buf + ((boff << 1) & ~0x1f);
789	boff &= 0xf;
790	xfer = min(len, 16 - boff);
791	while (len > 0) {
792		memcpy(to, bptr + boff, xfer);
793		to += xfer;
794		bptr += 32;
795		boff = 0;
796		len -= xfer;
797		xfer = min(len, 16);
798	}
799}
800
801static void
802lance_zerobuf_gap16(struct lance_softc *sc, int boff, int len)
803{
804	volatile caddr_t buf = sc->sc_mem;
805	caddr_t bptr;
806	int xfer;
807
808	bptr = buf + ((boff << 1) & ~0x1f);
809	boff &= 0xf;
810	xfer = min(len, 16 - boff);
811	while (len > 0) {
812		memset(bptr + boff, 0, xfer);
813		bptr += 32;
814		boff = 0;
815		len -= xfer;
816		xfer = min(len, 16);
817	}
818}
819#endif /* Example only */
820