Annotation of sys/arch/hp300/stand/common/if_le.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_le.c,v 1.5 2006/08/17 06:31:10 miod Exp $ */;
2: /* $NetBSD: if_le.c,v 1.9 1997/01/30 10:32:54 thorpej Exp $ */
3:
4: /*
5: * Copyright (c) 1993 Adam Glass
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by Adam Glass.
19: * 4. The name of the Author may not be used to endorse or promote products
20: * derived from this software without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY Adam Glass ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32: * SUCH DAMAGE.
33: */
34:
35: #include <sys/param.h>
36: #include <sys/types.h>
37:
38: #include <netinet/in.h>
39: #include <netinet/in_systm.h>
40:
41: #include <lib/libsa/stand.h>
42: #include <lib/libsa/netif.h>
43:
44: #include "samachdep.h"
45: #include "device.h"
46: #include "if_lereg.h"
47:
48: #ifndef NLE
49: #define NLE 1
50: #endif
51:
52: #ifdef LE_DEBUG
53: int le_debug = 0;
54: #endif
55:
56: #define ETHER_MIN_LEN 64
57: #define ETHER_MAX_LEN 1518
58: #define ETHER_ADDR_LEN 6
59:
60: int le_probe(struct netif *, void *);
61: int le_match(struct netif *, void *);
62: void le_init(struct iodesc *, void *);
63: int le_get(struct iodesc *, void *, size_t, time_t);
64: int le_put(struct iodesc *, void *, size_t);
65: void le_end(struct netif *);
66:
67: struct le_sel {
68: int le_id;
69: int le_regs;
70: int le_mem;
71: int le_nvram;
72: int le_heat;
73: int le_bonus;
74: } le0conf[] = {
75: /* offsets for: ID REGS MEM NVRAM le_heat le_bonus*/
76: { 0, 0x4000, 0x8000, 0xC008, 1, 10 }
77: };
78:
79: extern struct netif_stats le_stats[];
80:
81: struct netif_dif le_ifs[] = {
82: /* dif_unit dif_nsel dif_stats dif_private */
83: { 0, NENTS(le0conf), &le_stats[0], le0conf, },
84: };
85:
86: struct netif_stats le_stats[NENTS(le_ifs)];
87:
88: struct netif_driver le_driver = {
89: "le", /* netif_bname */
90: le_match, /* netif_match */
91: le_probe, /* netif_probe */
92: le_init, /* netif_init */
93: le_get, /* netif_get */
94: le_put, /* netif_put */
95: le_end, /* netif_end */
96: le_ifs, /* netif_ifs */
97: NENTS(le_ifs) /* netif_nifs */
98: };
99:
100: struct le_softc {
101: struct lereg0 *sc_r0; /* DIO registers */
102: struct lereg1 *sc_r1; /* LANCE registers */
103: void *sc_mem;
104: struct init_block *sc_init;
105: struct mds *sc_rd, *sc_td;
106: u_char *sc_rbuf, *sc_tbuf;
107: int sc_next_rd, sc_next_td;
108: u_char sc_addr[ETHER_ADDR_LEN];
109: } le_softc[NLE];
110:
111: static inline void
112: lewrcsr(struct le_softc *sc, u_short port, u_short val)
113: {
114: struct lereg0 *ler0 = sc->sc_r0;
115: struct lereg1 *ler1 = sc->sc_r1;
116:
117: do {
118: ler1->ler1_rap = port;
119: } while ((ler0->ler0_status & LE_ACK) == 0);
120: do {
121: ler1->ler1_rdp = val;
122: } while ((ler0->ler0_status & LE_ACK) == 0);
123: }
124:
125: static inline u_short
126: lerdcsr(struct le_softc *sc, u_short port)
127: {
128: struct lereg0 *ler0 = sc->sc_r0;
129: struct lereg1 *ler1 = sc->sc_r1;
130: u_short val;
131:
132: do {
133: ler1->ler1_rap = port;
134: } while ((ler0->ler0_status & LE_ACK) == 0);
135: do {
136: val = ler1->ler1_rdp;
137: } while ((ler0->ler0_status & LE_ACK) == 0);
138: return (val);
139: }
140:
141: void leinit(void);
142: void lememinit(struct le_softc *);
143: void le_error(int, char *, u_short);
144: int le_poll(struct iodesc *, void *, int);
145: void le_reset(int, u_char *);
146:
147: void
148: leinit()
149: {
150: extern struct hp_hw sc_table[];
151: struct hp_hw *hw;
152: struct le_softc *sc;
153: struct le_sel *sels;
154: int i, n;
155: char *cp;
156:
157: i = 0;
158:
159: for (hw = sc_table; i < NLE && hw < &sc_table[MAXCTLRS]; hw++) {
160: #ifdef LE_DEBUG
161: if (le_debug)
162: printf("found type %x\n", hw->hw_type);
163: #endif
164:
165: #if 0
166: if (!HW_ISDEV(hw, D_LAN))
167: continue;
168: #endif
169:
170: sels = (struct le_sel *)le_ifs[i].dif_private;
171:
172: sc = &le_softc[i];
173: sc->sc_r0 = (struct lereg0 *)(sels->le_id + (int)hw->hw_kva);
174:
175: if (sc->sc_r0->ler0_id != LEID)
176: continue;
177:
178: sc->sc_r1 = (struct lereg1 *)(sels->le_regs + (int)hw->hw_kva);
179: sc->sc_mem = (struct lereg2 *)(sels->le_mem + (int)hw->hw_kva);
180:
181: #ifdef LE_DEBUG
182: if (le_debug)
183: printf("le%d: DIO=%x regs=%x mem=%x\n",
184: i, sc->sc_r0, sc->sc_r1, sc->sc_mem);
185: #endif
186:
187: /*
188: * Read the ethernet address off the board, one nibble at a time.
189: */
190: cp = (char *)(sels->le_nvram + (int)hw->hw_kva);
191: for (n = 0; n < sizeof(sc->sc_addr); n++) {
192: sc->sc_addr[n] = (*++cp & 0xF) << 4;
193: cp++;
194: sc->sc_addr[n] |= *++cp & 0xF;
195: cp++;
196: }
197: #ifdef LE_DEBUG
198: if (le_debug)
199: printf("le%d at sc%d physical address %s\n",
200: i, hw->hw_sc, ether_sprintf(sc->sc_addr));
201: #endif
202: hw->hw_pa = (caddr_t) i; /* XXX for autoconfig */
203: i++;
204: }
205: }
206:
207: int
208: le_match(struct netif *nif, void *machdep_hint)
209: {
210: struct le_sel *sels;
211: char *name = machdep_hint;
212: int rv = 0;
213:
214: if (nif->nif_sel < le_ifs[nif->nif_unit].dif_nsel) {
215: sels = (struct le_sel *)le_ifs[nif->nif_unit].dif_private;
216: rv = sels[nif->nif_sel].le_heat;
217: if (name && !strncmp(le_driver.netif_bname, name, 2))
218: rv += sels[nif->nif_sel].le_bonus;
219: }
220: #ifdef LE_DEBUG
221: if (le_debug)
222: printf("le%d: sel %d --> %d\n", nif->nif_unit, nif->nif_sel,
223: rv);
224: #endif
225: return rv;
226: }
227:
228: int
229: le_probe(struct netif *nif, void *machdep_hint)
230: {
231:
232: /* the set unit is the current unit */
233: #ifdef LE_DEBUG
234: if (le_debug)
235: printf("le%d.%d: le_probe called\n", nif->nif_unit, nif->nif_sel);
236: #endif
237: /* XXX reset controller */
238: return 0;
239: }
240:
241: void
242: le_error(int unit, char *str, u_short stat)
243: {
244:
245: if (stat & LE_BABL)
246: panic("le%d: been babbling, found by '%s'", unit, str);
247: if (stat & LE_CERR)
248: le_stats[unit].collision_error++;
249: if (stat & LE_MISS)
250: le_stats[unit].missed++;
251: if (stat & LE_MERR) {
252: panic("le%d: memory error in '%s'\n", unit, str);
253: }
254: }
255:
256: #define LANCE_ADDR(sc, a) \
257: ((u_long)(a) - (u_long)sc->sc_mem)
258:
259: /* LANCE initialization block set up. */
260: void
261: lememinit(struct le_softc *sc)
262: {
263: int i;
264: void *mem;
265: u_long a;
266:
267: /*
268: * At this point we assume that the memory allocated to the Lance is
269: * quadword aligned. If it isn't then the initialisation is going
270: * fail later on.
271: */
272: mem = sc->sc_mem;
273:
274: sc->sc_init = mem;
275: sc->sc_init->mode = LE_NORMAL;
276: for (i = 0; i < ETHER_ADDR_LEN; i++)
277: sc->sc_init->padr[i] = sc->sc_addr[i^1];
278: sc->sc_init->ladrf[0] = sc->sc_init->ladrf[1] = 0;
279: mem += sizeof(struct init_block);
280:
281: sc->sc_rd = mem;
282: a = LANCE_ADDR(sc, mem);
283: sc->sc_init->rdra = a;
284: sc->sc_init->rlen = ((a >> 16) & 0xff) | (RLEN << 13);
285: mem += NRBUF * sizeof(struct mds);
286:
287: sc->sc_td = mem;
288: a = LANCE_ADDR(sc, mem);
289: sc->sc_init->tdra = a;
290: sc->sc_init->tlen = ((a >> 16) & 0xff) | (TLEN << 13);
291: mem += NTBUF * sizeof(struct mds);
292:
293: /*
294: * Set up receive ring descriptors.
295: */
296: sc->sc_rbuf = mem;
297: for (i = 0; i < NRBUF; i++) {
298: a = LANCE_ADDR(sc, mem);
299: sc->sc_rd[i].addr = a;
300: sc->sc_rd[i].flags = ((a >> 16) & 0xff) | LE_OWN;
301: sc->sc_rd[i].bcnt = -BUFSIZE;
302: sc->sc_rd[i].mcnt = 0;
303: mem += BUFSIZE;
304: }
305:
306: /*
307: * Set up transmit ring descriptors.
308: */
309: sc->sc_tbuf = mem;
310: for (i = 0; i < NTBUF; i++) {
311: a = LANCE_ADDR(sc, mem);
312: sc->sc_td[i].addr = a;
313: sc->sc_td[i].flags = ((a >> 16) & 0xff);
314: sc->sc_td[i].bcnt = 0xf000;
315: sc->sc_td[i].mcnt = 0;
316: mem += BUFSIZE;
317: }
318: }
319:
320: void
321: le_reset(int unit, u_char *myea)
322: {
323: struct le_softc *sc = &le_softc[unit];
324: u_long a;
325: int timo = 100000;
326:
327: #ifdef LE_DEBUG
328: if (le_debug) {
329: printf("le%d: le_reset called\n", unit);
330: printf(" r0=%x, r1=%x, mem=%x, addr=%x:%x:%x:%x:%x:%x\n",
331: sc->sc_r0, sc->sc_r1, sc->sc_mem,
332: sc->sc_addr[0], sc->sc_addr[1], sc->sc_addr[2],
333: sc->sc_addr[3], sc->sc_addr[4], sc->sc_addr[5]);
334: }
335: #endif
336: lewrcsr(sc, 0, LE_STOP);
337: for (timo = 1000; timo; timo--);
338:
339: sc->sc_next_rd = sc->sc_next_td = 0;
340:
341: /* Set up LANCE init block. */
342: lememinit(sc);
343:
344: if (myea)
345: bcopy(sc->sc_addr, myea, ETHER_ADDR_LEN);
346:
347: /* Turn on byte swapping. */
348: lewrcsr(sc, 3, LE_BSWP);
349:
350: /* Give LANCE the physical address of its init block. */
351: a = LANCE_ADDR(sc, sc->sc_init);
352: lewrcsr(sc, 1, a);
353: lewrcsr(sc, 2, (a >> 16) & 0xff);
354:
355: #ifdef LE_DEBUG
356: if (le_debug)
357: printf("le%d: before init\n", unit);
358: #endif
359:
360: /* Try to initialize the LANCE. */
361: lewrcsr(sc, 0, LE_INIT);
362:
363: /* Wait for initialization to finish. */
364: for (timo = 100000; timo; timo--)
365: if (lerdcsr(sc, 0) & LE_IDON)
366: break;
367:
368: if (lerdcsr(sc, 0) & LE_IDON) {
369: /* Start the LANCE. */
370: lewrcsr(sc, 0, LE_INEA | LE_STRT | LE_IDON);
371: } else
372: printf("le%d: card failed to initialize\n", unit);
373:
374: #ifdef LE_DEBUG
375: if (le_debug)
376: printf("le%d: after init\n", unit);
377: #endif
378: }
379:
380: int
381: le_poll(struct iodesc *desc, void *pkt, int len)
382: {
383: #if 0
384: struct netif *nif = desc->io_netif;
385: int unit = nif->nif_unit;
386: #else
387: int unit = 0;
388: #endif
389: struct le_softc *sc = &le_softc[unit];
390: int length;
391: volatile struct mds *cdm;
392: int stat;
393:
394: #ifdef LE_DEBUG
395: if (/*le_debug*/0)
396: printf("le%d: le_poll called. next_rd=%d\n", unit, sc->sc_next_rd);
397: #endif
398: stat = lerdcsr(sc, 0);
399: lewrcsr(sc, 0, stat & (LE_BABL | LE_MISS | LE_MERR | LE_RINT));
400: cdm = &sc->sc_rd[sc->sc_next_rd];
401: if (cdm->flags & LE_OWN)
402: return 0;
403: #ifdef LE_DEBUG
404: if (le_debug) {
405: printf("next_rd %d\n", sc->sc_next_rd);
406: printf("cdm->flags %x\n", cdm->flags);
407: printf("cdm->bcnt %x, cdm->mcnt %x\n", cdm->bcnt, cdm->mcnt);
408: printf("cdm->rbuf msg %d buf %d\n", cdm->mcnt, -cdm->bcnt );
409: }
410: #endif
411: if (stat & (LE_BABL | LE_CERR | LE_MISS | LE_MERR))
412: le_error(unit, "le_poll", stat);
413: if (cdm->flags & (LE_FRAM | LE_OFLO | LE_CRC | LE_RBUFF)) {
414: printf("le%d_poll: rmd status 0x%x\n", unit, cdm->flags);
415: length = 0;
416: goto cleanup;
417: }
418: if ((cdm->flags & (LE_STP|LE_ENP)) != (LE_STP|LE_ENP))
419: panic("le_poll: chained packet");
420:
421: length = cdm->mcnt;
422: #ifdef LE_DEBUG
423: if (le_debug)
424: printf("le_poll: length %d\n", length);
425: #endif
426: if (length >= BUFSIZE) {
427: length = 0;
428: panic("csr0 when bad things happen: %x", stat);
429: goto cleanup;
430: }
431: if (!length)
432: goto cleanup;
433: length -= 4;
434:
435: if (length > 0) {
436: /*
437: * If the length of the packet is greater than the size of the
438: * buffer, we have to truncate it, to avoid Bad Things.
439: * XXX Is this the right thing to do?
440: */
441: if (length > len)
442: length = len;
443:
444: bcopy(sc->sc_rbuf + (BUFSIZE * sc->sc_next_rd), pkt, length);
445: }
446:
447: cleanup:
448: cdm->mcnt = 0;
449: cdm->flags |= LE_OWN;
450: if (++sc->sc_next_rd >= NRBUF)
451: sc->sc_next_rd = 0;
452: #ifdef LE_DEBUG
453: if (le_debug)
454: printf("new next_rd %d\n", sc->sc_next_rd);
455: #endif
456:
457: return length;
458: }
459:
460: int
461: le_put(struct iodesc *desc, void *pkt, size_t len)
462: {
463: #if 0
464: struct netif *nif = desc->io_netif;
465: int unit = nif->nif_unit;
466: #else
467: int unit = 0;
468: #endif
469: struct le_softc *sc = &le_softc[unit];
470: volatile struct mds *cdm;
471: int timo, i, stat;
472:
473: le_put_loop:
474: timo = 100000;
475:
476: #ifdef LE_DEBUG
477: if (le_debug)
478: printf("le%d: le_put called. next_td=%d\n", unit, sc->sc_next_td);
479: #endif
480: stat = lerdcsr(sc, 0);
481: lewrcsr(sc, 0, stat & (LE_BABL | LE_MISS | LE_MERR | LE_TINT));
482: if (stat & (LE_BABL | LE_CERR | LE_MISS | LE_MERR))
483: le_error(unit, "le_put(way before xmit)", stat);
484: cdm = &sc->sc_td[sc->sc_next_td];
485: i = 0;
486: #if 0
487: while (cdm->flags & LE_OWN) {
488: if ((i % 100) == 0)
489: printf("le%d: output buffer busy - flags=%x\n",
490: unit, cdm->flags);
491: if (i++ > 500) break;
492: }
493: if (cdm->flags & LE_OWN)
494: getchar();
495: #else
496: while (cdm->flags & LE_OWN);
497: #endif
498: bcopy(pkt, sc->sc_tbuf + (BUFSIZE * sc->sc_next_td), len);
499: if (len < ETHER_MIN_LEN)
500: cdm->bcnt = -ETHER_MIN_LEN;
501: else
502: cdm->bcnt = -len;
503: cdm->mcnt = 0;
504: cdm->flags |= LE_OWN | LE_STP | LE_ENP;
505: stat = lerdcsr(sc, 0);
506: if (stat & (LE_BABL | LE_CERR | LE_MISS | LE_MERR))
507: le_error(unit, "le_put(before xmit)", stat);
508: lewrcsr(sc, 0, LE_TDMD);
509: stat = lerdcsr(sc, 0);
510: if (stat & (LE_BABL | LE_CERR | LE_MISS | LE_MERR))
511: le_error(unit, "le_put(after xmit)", stat);
512: do {
513: if (--timo == 0) {
514: printf("le%d: transmit timeout, stat = 0x%x\n",
515: unit, stat);
516: if (stat & LE_SERR)
517: le_error(unit, "le_put(timeout)", stat);
518: if (stat & LE_INIT) {
519: printf("le%d: reset and retry packet\n", unit);
520: lewrcsr(sc, 0, LE_TINT); /* sanity */
521: le_init(desc, NULL);
522: goto le_put_loop;
523: }
524: break;
525: }
526: stat = lerdcsr(sc, 0);
527: } while ((stat & LE_TINT) == 0);
528: lewrcsr(sc, 0, LE_TINT);
529: if (stat & (LE_BABL |/* LE_CERR |*/ LE_MISS | LE_MERR)) {
530: printf("le_put: xmit error, buf %d\n", sc->sc_next_td);
531: le_error(unit, "le_put(xmit error)", stat);
532: }
533: if (++sc->sc_next_td >= NTBUF)
534: sc->sc_next_td = 0;
535: if (cdm->flags & LE_DEF)
536: le_stats[unit].deferred++;
537: if (cdm->flags & LE_ONE)
538: le_stats[unit].collisions++;
539: if (cdm->flags & LE_MORE)
540: le_stats[unit].collisions+=2;
541: if (cdm->flags & LE_ERR) {
542: printf("le%d: transmit error, error = 0x%x\n", unit,
543: cdm->mcnt);
544: return -1;
545: }
546: #ifdef LE_DEBUG
547: if (le_debug) {
548: printf("le%d: le_put() successful: sent %d\n", unit, len);
549: printf("le%d: le_put(): flags: %x mcnt: %x\n", unit,
550: (unsigned int) cdm->flags,
551: (unsigned int) cdm->mcnt);
552: }
553: #endif
554: return len;
555: }
556:
557:
558: int
559: le_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
560: {
561: time_t t;
562: int cc;
563:
564: t = getsecs();
565: cc = 0;
566: while (((getsecs() - t) < timeout) && !cc) {
567: cc = le_poll(desc, pkt, len);
568: }
569: return cc;
570: }
571:
572: void
573: le_init(struct iodesc *desc, void *machdep_hint)
574: {
575: struct netif *nif = desc->io_netif;
576: int unit = nif->nif_unit;
577:
578: /* Get machine's common ethernet interface. This is done in leinit() */
579: /* machdep_common_ether(myea); */
580: leinit();
581:
582: #ifdef LE_DEBUG
583: if (le_debug)
584: printf("le%d: le_init called\n", unit);
585: #endif
586: unit = 0;
587: le_reset(unit, desc->myea);
588: }
589:
590: void
591: le_end(struct netif *nif)
592: {
593: int unit = nif->nif_unit;
594:
595: #ifdef LE_DEBUG
596: if (le_debug)
597: printf("le%d: le_end called\n", unit);
598: #endif
599:
600: lewrcsr(&le_softc[unit], 0, LE_STOP);
601: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_le.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / stand / common