FreeBSD/Linux Kernel Cross Reference
sys/dev/qbus/if_qt.c
1 /* $NetBSD: if_qt.c,v 1.27 2022/09/02 23:48:10 thorpej Exp $ */
2 /*
3 * Copyright (c) 1992 Steven M. Schultz
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * @(#)if_qt.c 1.2 (2.11BSD) 2/20/93
29 */
30 /*
31 *
32 * Modification History
33 * 23-Feb-92 -- sms
34 * Rewrite the buffer handling so that fewer than the maximum number of
35 * buffers may be used (32 receive and 12 transmit buffers consume 66+kb
36 * of main system memory in addition to the internal structures in the
37 * networking code). A freelist of available buffers is maintained now.
38 * When I/O operations complete the associated buffer is placed on the
39 * freelist (a single linked list for simplicity) and when an I/O is
40 * started a buffer is pulled off the list.
41 *
42 * 20-Feb-92 -- sms
43 * It works! Darned board couldn't handle "short" rings - those rings
44 * where only half the entries were made available to the board (the
45 * ring descriptors were the full size, merely half the entries were
46 * flagged as belonging always to the driver). Grrrr. Would have thought
47 * the board could skip over those entries reserved by the driver.
48 * Now to find a way not to have to allocated 32+12 times 1.5kb worth of
49 * buffers...
50 *
51 * 03-Feb-92 -- sms
52 * Released but still not working. The driver now responds to arp and
53 * ping requests. The board is apparently not returning ring descriptors
54 * to the driver so eventually we run out of buffers. Back to the
55 * drawing board.
56 *
57 * 28-Dec-92 -- sms
58 * Still not released. Hiatus in finding free time and thin-netting
59 * the systems (many thanks Terry!).
60 * Added logic to dynamically allocate a vector and initialize it.
61 *
62 * 23-Oct-92 -- sms
63 * The INIT block must (apparently) be quadword aligned [no thanks to
64 * the manual for not mentioning that fact]. The necessary alignment
65 * is achieved by allocating the INIT block from main memory ('malloc'
66 * guarantees click alignment) and mapping it as needed (which is _very_
67 * infrequently). A check for quadword alignment of the ring descriptors
68 * was added - at present the descriptors are properly aligned, if this
69 * should change then something will have to be done (like do it "right").
70 * Darned alignment restrictions!
71 *
72 * A couple of typos were corrected (missing parentheses, reversed
73 * arguments to printf calls, etc).
74 *
75 * 13-Oct-92 -- sms@wlv.iipo.gtegsc.com
76 * Created based on the DELQA-PLUS addendum to DELQA User's Guide.
77 * This driver ('qt') is selected at system configuration time. If the
78 * board * is not a DELQA-YM an error message will be printed and the
79 * interface will not be attached.
80 */
81
82 #include <sys/cdefs.h>
83 __KERNEL_RCSID(0, "$NetBSD: if_qt.c,v 1.27 2022/09/02 23:48:10 thorpej Exp $");
84
85 #include "opt_inet.h"
86
87 #include <sys/param.h>
88 #include <sys/systm.h>
89 #include <sys/mbuf.h>
90 #include <sys/protosw.h>
91 #include <sys/socket.h>
92 #include <sys/ioctl.h>
93 #include <sys/device.h>
94 #include <sys/errno.h>
95 #include <sys/syslog.h>
96 #include <sys/time.h>
97 #include <sys/kernel.h>
98
99 #include <net/if.h>
100 #include <net/if_ether.h>
101 #include <net/route.h>
102 #include <net/bpf.h>
103
104 #ifdef INET
105 #include <sys/domain.h>
106 #include <netinet/in.h>
107 #include <netinet/in_systm.h>
108 #include <netinet/in_var.h>
109 #include <netinet/ip.h>
110 #endif
111
112 #include <sys/bus.h>
113
114 #include <dev/qbus/ubavar.h>
115 #include <dev/qbus/if_uba.h>
116 #include <dev/qbus/if_qtreg.h>
117
118 #define NRCV QT_MAX_RCV /* Receive descriptors (must be == 32) */
119 #define NXMT QT_MAX_XMT /* Transmit descriptors (must be == 12) */
120 #if NRCV != 32 || NXMT != 12
121 hardware requires these sizes.
122 #endif
123
124 /*
125 * Control data structures, must be in DMA-friendly memory.
126 */
127 struct qt_cdata {
128 struct qt_init qc_init; /* Init block */
129 struct qt_rring qc_r[NRCV]; /* Receive descriptor ring */
130 struct qt_tring qc_t[NXMT]; /* Transmit descriptor ring */
131 };
132
133 struct qt_softc {
134 device_t sc_dev; /* Configuration common part */
135 struct ethercom is_ec; /* common part - must be first */
136 struct uba_softc *sc_uh;
137 struct evcnt sc_intrcnt; /* Interrupt counting */
138 #define is_if is_ec.ec_if /* network-visible interface */
139 u_int8_t is_addr[ETHER_ADDR_LEN]; /* hardware Ethernet address */
140 bus_space_tag_t sc_iot;
141 bus_addr_t sc_ioh;
142
143 struct ubinfo sc_ui; /* control block address desc */
144 struct qt_cdata *sc_ib; /* virt address of ctrl block */
145 struct qt_cdata *sc_pib; /* phys address of ctrl block */
146
147 struct ifubinfo sc_ifuba; /* UNIBUS resources */
148 struct ifrw sc_ifr[NRCV]; /* UNIBUS receive buffer maps */
149 struct ifxmt sc_ifw[NXMT]; /* UNIBUS receive buffer maps */
150
151 int rindex; /* Receive Completed Index */
152 int nxtrcv; /* Next Receive Index */
153 int nrcv; /* Number of Receives active */
154
155 int xnext; /* Next descriptor to transmit */
156 int xlast; /* Last descriptor transmitted */
157 int nxmit; /* # packets in send queue */
158
159 short vector; /* Interrupt vector assigned */
160 };
161
162 static int qtmatch(device_t, cfdata_t, void *);
163 static void qtattach(device_t, device_t, void *);
164 static void lance_setladrf(struct ethercom *ec, uint16_t *af);
165 static void qtintr(void *);
166 static int qtinit(struct ifnet *);
167 static int qtioctl(struct ifnet *, u_long, void *);
168 static int qtturbo(struct qt_softc *);
169 static void qtstart(struct ifnet *ifp);
170 static void qtstop(struct ifnet *ifp, int disable);
171 static void qtsrr(struct qt_softc *, int);
172 static void qtrint(struct qt_softc *sc);
173 static void qttint(struct qt_softc *sc);
174
175 /* static void qtrestart(struct qt_softc *sc); */
176
177 CFATTACH_DECL_NEW(qt, sizeof(struct qt_softc),
178 qtmatch, qtattach, NULL, NULL);
179
180 /*
181 * Maximum packet size needs to include 4 bytes for the CRC
182 * on received packets.
183 */
184 #define MAXPACKETSIZE (ETHERMTU + sizeof (struct ether_header) + 4)
185 #define MINPACKETSIZE 64
186
187 #define QT_WCSR(csr, val) \
188 bus_space_write_2(sc->sc_iot, sc->sc_ioh, csr, val)
189 #define QT_RCSR(csr) \
190 bus_space_read_2(sc->sc_iot, sc->sc_ioh, csr)
191
192
193 #define loint(x) ((int)(x) & 0xffff)
194 #define hiint(x) (((int)(x) >> 16) & 0x3f)
195
196 /*
197 * Check if this card is a turbo delqa.
198 */
199 int
200 qtmatch(device_t parent, cfdata_t cf, void *aux)
201 {
202 struct qt_softc ssc;
203 struct qt_softc *sc = &ssc;
204 struct uba_attach_args *ua = aux;
205 struct uba_softc *uh = device_private(parent);
206 struct qt_init *qi;
207 struct ubinfo ui;
208
209 sc->sc_iot = ua->ua_iot;
210 sc->sc_ioh = ua->ua_ioh;
211 if (qtturbo(sc) == 0)
212 return 0; /* Not a turbo card */
213
214 /* Force the card to interrupt */
215 ui.ui_size = sizeof(struct qt_init);
216 if (ubmemalloc(uh, &ui, 0))
217 return 0; /* Failed */
218 qi = (struct qt_init *)ui.ui_vaddr;
219 memset(qi, 0, sizeof(struct qt_init));
220 qi->vector = uh->uh_lastiv - 4;
221 qi->options = INIT_OPTIONS_INT;
222
223 QT_WCSR(CSR_IBAL, loint(ui.ui_baddr));
224 QT_WCSR(CSR_IBAH, hiint(ui.ui_baddr));
225 QT_WCSR(CSR_SRQR, 2);
226 delay(100000); /* Wait some time for interrupt */
227 QT_WCSR(CSR_SRQR, 3); /* Stop card */
228
229 ubmemfree(uh, &ui);
230
231 return 10;
232 }
233
234
235 /*
236 * Interface exists. More accurately, something exists at the CSR (see
237 * sys/sys_net.c) -- there's no guarantee it's a DELQA-YM.
238 *
239 * The ring descriptors are initialized, the buffers allocated using first the
240 * DMA region allocated at network load time and then later main memory. The
241 * INIT block is filled in and the device is poked/probed to see if it really
242 * is a DELQA-YM. If the device is not a -YM then a message is printed and
243 * the 'if_attach' call is skipped. For a -YM the START command is issued,
244 * but the device is not marked as running|up - that happens at interrupt level
245 * when the device interrupts to say it has started.
246 */
247
248 void
249 qtattach(device_t parent, device_t self, void *aux)
250 {
251 struct qt_softc *sc = device_private(self);
252 struct ifnet *ifp = &sc->is_if;
253 struct uba_attach_args *ua = aux;
254
255 sc->sc_dev = self;
256
257 uba_intr_establish(ua->ua_icookie, ua->ua_cvec, qtintr, sc,
258 &sc->sc_intrcnt);
259 evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, ua->ua_evcnt,
260 device_xname(sc->sc_dev), "intr");
261
262 sc->sc_uh = device_private(parent);
263 sc->sc_iot = ua->ua_iot;
264 sc->sc_ioh = ua->ua_ioh;
265 sc->sc_uh->uh_lastiv -= 4;
266 sc->vector = sc->sc_uh->uh_lastiv;
267
268 /*
269 * Now allocate the buffers and initialize the buffers. This should _never_
270 * fail because main memory is allocated after the DMA pool is used up.
271 */
272
273 sc->is_addr[0] = QT_RCSR(0);
274 sc->is_addr[1] = QT_RCSR(2);
275 sc->is_addr[2] = QT_RCSR(4);
276 sc->is_addr[3] = QT_RCSR(6);
277 sc->is_addr[4] = QT_RCSR(8);
278 sc->is_addr[5] = QT_RCSR(10);
279
280 strcpy(ifp->if_xname, device_xname(sc->sc_dev));
281 ifp->if_softc = sc;
282 ifp->if_flags = IFF_BROADCAST|IFF_MULTICAST;
283 ifp->if_ioctl = qtioctl;
284 ifp->if_start = qtstart;
285 ifp->if_init = qtinit;
286 ifp->if_stop = qtstop;
287 IFQ_SET_READY(&ifp->if_snd);
288
289 printf("\n%s: delqa-plus in Turbo mode, hardware address %s\n",
290 device_xname(sc->sc_dev), ether_sprintf(sc->is_addr));
291 if_attach(ifp);
292 ether_ifattach(ifp, sc->is_addr);
293 }
294
295 int
296 qtturbo(struct qt_softc *sc)
297 {
298 int i;
299
300 /*
301 * Issue the software reset. Delay 150us. The board should now be in
302 * DELQA-Normal mode. Set ITB and DEQTA select. If both bits do not
303 * stay turned on then the board is not a DELQA-YM.
304 */
305 QT_WCSR(CSR_ARQR, ARQR_SR);
306 QT_WCSR(CSR_ARQR, 0);
307 delay(150L);
308
309 QT_WCSR(CSR_SRR, 0x8001); /* MS | ITB */
310 i = QT_RCSR(CSR_SRR);
311 QT_WCSR(CSR_SRR, 0x8000); /* Turn off ITB, set DELQA select */
312 if (i != 0x8001)
313 return(0);
314 /*
315 * Board is a DELQA-YM. Send the commands to enable Turbo mode. Delay
316 * 1 second, testing the SRR register every millisecond to see if the
317 * board has shifted to Turbo mode.
318 */
319 QT_WCSR(CSR_XCR0, 0x0baf);
320 QT_WCSR(CSR_XCR1, 0xff00);
321 for (i = 0; i < 1000; i++)
322 {
323 if ((QT_RCSR(CSR_SRR) & SRR_RESP) == 1)
324 break;
325 delay(1000L);
326 }
327 if (i >= 1000)
328 {
329 printf("qt !Turbo\n");
330 return(0);
331 }
332 return(1);
333 }
334
335 #define ETHER_CMP(a,b) memcmp((a), (b), 6)
336
337 /*
338 * Set up the logical address filter.
339 */
340 void
341 lance_setladrf(struct ethercom *ec, uint16_t *af)
342 {
343 struct ifnet *ifp = &ec->ec_if;
344 struct ether_multi *enm;
345 uint32_t crc;
346 struct ether_multistep step;
347
348 /*
349 * Set up multicast address filter by passing all multicast addresses
350 * through a crc generator, and then using the high order 6 bits as an
351 * index into the 64 bit logical address filter. The high order bit
352 * selects the word, while the rest of the bits select the bit within
353 * the word.
354 */
355
356 if (ifp->if_flags & IFF_PROMISC)
357 goto allmulti;
358
359 af[0] = af[1] = af[2] = af[3] = 0x0000;
360
361 ETHER_LOCK(ec);
362 ETHER_FIRST_MULTI(step, ec, enm);
363 while (enm != NULL) {
364 if (ETHER_CMP(enm->enm_addrlo, enm->enm_addrhi)) {
365 /*
366 * We must listen to a range of multicast addresses.
367 * For now, just accept all multicasts, rather than
368 * trying to set only those filter bits needed to match
369 * the range. (At this time, the only use of address
370 * ranges is for IP multicast routing, for which the
371 * range is big enough to require all bits set.)
372 */
373 ETHER_UNLOCK(ec);
374 goto allmulti;
375 }
376
377 crc = ether_crc32_le(enm->enm_addrlo, ETHER_ADDR_LEN);
378
379 /* Just want the 6 most significant bits. */
380 crc >>= 26;
381
382 /* Set the corresponding bit in the filter. */
383 af[crc >> 4] |= 1 << (crc & 0xf);
384
385 ETHER_NEXT_MULTI(step, enm);
386 }
387 ETHER_UNLOCK(ec);
388 ifp->if_flags &= ~IFF_ALLMULTI;
389 return;
390
391 allmulti:
392 ifp->if_flags |= IFF_ALLMULTI;
393 af[0] = af[1] = af[2] = af[3] = 0xffff;
394 }
395
396 int
397 qtinit(struct ifnet *ifp)
398 {
399 struct qt_softc *sc = ifp->if_softc;
400 struct qt_init *iniblk;
401 struct ifrw *ifrw;
402 struct ifxmt *ifxp;
403 struct qt_rring *rp;
404 struct qt_tring *tp;
405 int i, error;
406
407 if (ifp->if_flags & IFF_RUNNING) {
408 /* Cancel any pending I/O. */
409 qtstop(ifp, 0);
410 }
411
412 if (sc->sc_ib == NULL) {
413 if (if_ubaminit(&sc->sc_ifuba, sc->sc_uh,
414 MCLBYTES, sc->sc_ifr, NRCV, sc->sc_ifw, NXMT)) {
415 printf("%s: can't initialize\n", device_xname(sc->sc_dev));
416 ifp->if_flags &= ~IFF_UP;
417 return 0;
418 }
419 sc->sc_ui.ui_size = sizeof(struct qt_cdata);
420 if ((error = ubmemalloc(sc->sc_uh, &sc->sc_ui, 0))) {
421 printf(": failed ubmemalloc(), error = %d\n", error);
422 return error;
423 }
424 sc->sc_ib = (struct qt_cdata *)sc->sc_ui.ui_vaddr;
425 sc->sc_pib = (struct qt_cdata *)sc->sc_ui.ui_baddr;
426
427 /*
428 * Fill in most of the INIT block: vector, options (interrupt enable), ring
429 * locations. The physical address is copied from the ROMs as part of the
430 * -YM testing procedure. The CSR is saved here rather than in qtinit()
431 * because the qtturbo() routine needs it.
432 *
433 * The INIT block must be quadword aligned. Using malloc() guarantees click
434 * (64 byte) alignment. Since the only time the INIT block is referenced is
435 * at 'startup' or 'reset' time there is really no time penalty (and a modest
436 * D space savings) involved.
437 */
438 memset(sc->sc_ib, 0, sizeof(struct qt_cdata));
439 iniblk = &sc->sc_ib->qc_init;
440
441 iniblk->vector = sc->vector;
442 memcpy(iniblk->paddr, sc->is_addr, 6);
443
444 iniblk->options = INIT_OPTIONS_INT;
445 iniblk->rx_lo = loint(&sc->sc_pib->qc_r);
446 iniblk->rx_hi = hiint(&sc->sc_pib->qc_r);
447 iniblk->tx_lo = loint(&sc->sc_pib->qc_t);
448 iniblk->tx_hi = hiint(&sc->sc_pib->qc_t);
449 }
450 iniblk = &sc->sc_ib->qc_init;
451 iniblk->mode = ifp->if_flags & IFF_PROMISC ? INIT_MODE_PRO : 0;
452 /*
453 * The multicast filter works "like LANCE".
454 */
455 lance_setladrf(&sc->is_ec, iniblk->laddr);
456
457 /*
458 * Now initialize the receive ring descriptors. Because this routine can be
459 * called with outstanding I/O operations we check the ring descriptors for
460 * a non-zero 'rhost0' (or 'thost0') word and place those buffers back on
461 * the free list.
462 */
463 for (i = 0; i < NRCV; i++) {
464 rp = &sc->sc_ib->qc_r[i];
465 ifrw = &sc->sc_ifr[i];
466 rp->rmd1 = MCLBYTES;
467 rp->rmd4 = loint(ifrw->ifrw_info);
468 rp->rmd5 = hiint(ifrw->ifrw_info);
469 rp->rmd3 = 0; /* clear RMD3_OWN */
470 }
471 for (i = 0; i < NXMT; i++) {
472 tp = &sc->sc_ib->qc_t[i];
473 ifxp = &sc->sc_ifw[i];
474 tp->tmd4 = loint(ifxp->ifw_info);
475 tp->tmd5 = hiint(ifxp->ifw_info);
476 tp->tmd3 = TMD3_OWN;
477 }
478
479 sc->xnext = sc->xlast = sc->nxmit = 0;
480 sc->rindex = 0;
481 sc->nxtrcv = 0;
482 sc->nrcv = 0;
483
484 /*
485 * Now we tell the device the address of the INIT block. The device
486 * _must_ be in the Turbo mode at this time. The "START" command is
487 * then issued to the device. A 1 second timeout is then started.
488 * When the interrupt occurs the IFF_UP|IFF_RUNNING state is entered and
489 * full operations will proceed. If the timeout expires without an interrupt
490 * being received an error is printed, the flags cleared and the device left
491 * marked down.
492 */
493 QT_WCSR(CSR_IBAL, loint(&sc->sc_pib->qc_init));
494 QT_WCSR(CSR_IBAH, hiint(&sc->sc_pib->qc_init));
495 QT_WCSR(CSR_SRQR, 2);
496
497 sc->is_if.if_flags |= IFF_RUNNING;
498 return 0;
499 }
500
501 /*
502 * Start output on interface.
503 */
504
505 void
506 qtstart(struct ifnet *ifp)
507 {
508 int len, nxmit;
509 struct qt_softc *sc = ifp->if_softc;
510 struct qt_tring *rp;
511 struct mbuf *m = NULL;
512
513 for (nxmit = sc->nxmit; nxmit < NXMT; nxmit++) {
514 IF_DEQUEUE(&sc->is_if.if_snd, m);
515 if (m == 0)
516 break;
517
518 rp = &sc->sc_ib->qc_t[sc->xnext];
519 if ((rp->tmd3 & TMD3_OWN) == 0)
520 panic("qtstart");
521
522 bpf_mtap(ifp, m, BPF_D_OUT);
523
524 len = if_ubaput(&sc->sc_ifuba, &sc->sc_ifw[sc->xnext], m);
525 if (len < MINPACKETSIZE)
526 len = MINPACKETSIZE;
527 rp->tmd3 = len & TMD3_BCT; /* set length,clear ownership */
528 QT_WCSR(CSR_ARQR, ARQR_TRQ); /* tell device it has buffer */
529
530 if (++sc->xnext >= NXMT)
531 sc->xnext = 0;
532 }
533 if (sc->nxmit != nxmit)
534 sc->nxmit = nxmit;
535 /* XXX - set OACTIVE */
536 }
537
538 /*
539 * General interrupt service routine. Receive, transmit, device start
540 * interrupts and timeouts come here. Check for hard device errors and print a
541 * message if any errors are found. If we are waiting for the device to
542 * START then check if the device is now running.
543 */
544
545 void
546 qtintr(void *arg)
547 {
548 struct qt_softc *sc = arg;
549 struct ifnet *ifp = &sc->is_if;
550 short status;
551
552
553 status = QT_RCSR(CSR_SRR);
554 if (status < 0)
555 /* should we reset the device after a bunch of these errs? */
556 qtsrr(sc, status);
557 if ((ifp->if_flags & IFF_UP) == 0)
558 return; /* Unwanted interrupt */
559 qtrint(sc);
560 qttint(sc);
561 qtstart(&sc->is_ec.ec_if);
562 }
563
564 /*
565 * Transmit interrupt service. Only called if there are outstanding transmit
566 * requests which could have completed. The DELQA-YM doesn't provide the
567 * status bits telling the kind (receive, transmit) of interrupt.
568 */
569
570 #define BBLMIS (TMD2_BBL|TMD2_MIS)
571
572 void
573 qttint(struct qt_softc *sc)
574 {
575 struct qt_tring *rp;
576
577 while (sc->nxmit > 0) {
578 rp = &sc->sc_ib->qc_t[sc->xlast];
579 if ((rp->tmd3 & TMD3_OWN) == 0)
580 break;
581 if_statinc(&sc->is_if, if_opackets);
582 /*
583 * Collisions don't count as output errors, but babbling and missing packets
584 * do count as output errors.
585 */
586 if (rp->tmd2 & TMD2_CER)
587 if_statinc(&sc->is_if, if_collisions);
588 if ((rp->tmd0 & TMD0_ERR1) ||
589 ((rp->tmd2 & TMD2_ERR2) && (rp->tmd2 & BBLMIS))) {
590 #ifdef QTDEBUG
591 char buf[100];
592 snprintb(buf, sizeof(buf), TMD2_BITS, rp->tmd2);
593 printf("%s: tmd2 %s\n", device_xname(sc->sc_dev), buf);
594 #endif
595 if_statinc(&sc->is_if, if_oerrors);
596 }
597 if_ubaend(&sc->sc_ifuba, &sc->sc_ifw[sc->xlast]);
598 if (++sc->xlast >= NXMT)
599 sc->xlast = 0;
600 sc->nxmit--;
601 }
602 }
603
604 /*
605 * Receive interrupt service. Pull packet off the interface and put into
606 * a mbuf chain for processing later.
607 */
608
609 void
610 qtrint(struct qt_softc *sc)
611 {
612 struct qt_rring *rp;
613 struct ifnet *ifp = &sc->is_ec.ec_if;
614 struct mbuf *m;
615 int len;
616
617 while (sc->sc_ib->qc_r[(int)sc->rindex].rmd3 & RMD3_OWN)
618 {
619 rp = &sc->sc_ib->qc_r[(int)sc->rindex];
620 if ((rp->rmd0 & (RMD0_STP|RMD0_ENP)) != (RMD0_STP|RMD0_ENP)) {
621 printf("%s: chained packet\n", device_xname(sc->sc_dev));
622 if_statinc(&sc->is_if, if_ierrors);
623 goto rnext;
624 }
625 len = (rp->rmd1 & RMD1_MCNT) - 4; /* -4 for CRC */
626
627 if ((rp->rmd0 & RMD0_ERR3) || (rp->rmd2 & RMD2_ERR4)) {
628 #ifdef QTDEBUG
629 char buf[100];
630 snprintb(buf, sizeof(buf), RMD0_BITS, rp->rmd0);
631 printf("%s: rmd0 %s\n", device_xname(sc->sc_dev), buf);
632 snprintb(buf, sizeof(buf), RMD2_BITS, rp->rmd2);
633 printf("%s: rmd2 %s\n", device_xname(sc->sc_dev), buf);
634 #endif
635 if_statinc(&sc->is_if, if_ierrors);
636 goto rnext;
637 }
638 m = if_ubaget(&sc->sc_ifuba, &sc->sc_ifr[(int)sc->rindex],
639 ifp, len);
640 if (m == 0) {
641 if_statinc(&sc->is_if, if_ierrors);
642 goto rnext;
643 }
644 if_percpuq_enqueue(ifp->if_percpuq, m);
645 rnext:
646 --sc->nrcv;
647 rp->rmd3 = 0;
648 rp->rmd1 = MCLBYTES;
649 if (++sc->rindex >= NRCV)
650 sc->rindex = 0;
651 }
652 QT_WCSR(CSR_ARQR, ARQR_RRQ); /* tell device it has buffer */
653 }
654
655 int
656 qtioctl(struct ifnet *ifp, u_long cmd, void *data)
657 {
658 int s, error;
659
660 s = splnet();
661
662 error = ether_ioctl(ifp, cmd, data);
663 if (error == ENETRESET) {
664 if (ifp->if_flags & IFF_RUNNING)
665 error = qtinit(ifp);
666 else
667 error = 0;
668 }
669 splx(s);
670 return (error);
671 }
672
673 void
674 qtsrr(struct qt_softc *sc, int srrbits)
675 {
676 char buf[100];
677 snprintb(buf, sizeof(buf), SRR_BITS, srrbits);
678 printf("%s: srr=%s\n", device_xname(sc->sc_dev), buf);
679 }
680
681 /*
682 * Stop activity on the interface.
683 * Lose outstanding transmit requests. XXX - not good for multicast.
684 */
685 void
686 qtstop(struct ifnet *ifp, int disable)
687 {
688 struct qt_softc *sc = ifp->if_softc;
689 int i;
690
691 QT_WCSR(CSR_SRQR, 3);
692 for (i = 0; i < 100; i++)
693 if ((QT_RCSR(CSR_SRR) & SRR_RESP) == 3)
694 break;
695 if (QT_RCSR(CSR_SRR) & SRR_FES)
696 qtsrr(sc, QT_RCSR(CSR_SRR));
697 /* Forget already queued transmit requests */
698 while (sc->nxmit > 0) {
699 if_ubaend(&sc->sc_ifuba, &sc->sc_ifw[sc->xlast]);
700 if (++sc->xlast >= NXMT)
701 sc->xlast = 0;
702 sc->nxmit--;
703 }
704 /* Handle late received packets */
705 qtrint(sc);
706 ifp->if_flags &= ~IFF_RUNNING;
707 }
708
709 #ifdef notyet
710 /*
711 * Reset the device. This moves it from DELQA-T mode to DELQA-Normal mode.
712 * After the reset put the device back in -T mode. Then call qtinit() to
713 * reinitialize the ring structures and issue the 'timeout' for the "device
714 * started interrupt".
715 */
716
717 void
718 qtreset(sc)
719 struct qt_softc *sc;
720 {
721
722 qtturbo(sc);
723 qtinit(&sc->is_ec.ec_if);
724 }
725 #endif
Cache object: 31b38d1619c7b0a7397275a83f877f7c
|