This source file includes following definitions.
- tulip_timeout_callback
- tulip_timeout
- tulip_txprobe
- tulip_media_set
- tulip_linkup
- tulip_media_print
- tulip_media_link_monitor
- tulip_media_poll
- tulip_media_select
- tulip_21040_mediainfo_init
- tulip_21040_media_probe
- tulip_21040_10baset_only_media_probe
- tulip_21040_10baset_only_media_select
- tulip_21040_auibnc_only_media_probe
- tulip_21040_auibnc_only_media_select
- tulip_21041_mediainfo_init
- tulip_21041_media_noprobe
- tulip_21041_media_probe
- tulip_21041_media_poll
- tulip_mii_phy_readspecific
- tulip_mii_get_phyaddr
- tulip_mii_map_abilities
- tulip_mii_autonegotiate
- tulip_2114x_media_preset
- tulip_null_media_poll
- tulip_21140_mediainit
- tulip_21140_evalboard_media_probe
- tulip_21140_accton_media_probe
- tulip_21140_smc9332_media_probe
- tulip_21140_cogent_em100_media_probe
- tulip_21140_znyx_zx34x_media_probe
- tulip_2114x_media_probe
- tulip_delay_300ns
- tulip_srom_idle
- tulip_srom_read
- tulip_mii_writebits
- tulip_mii_turnaround
- tulip_mii_readbits
- tulip_mii_readreg
- tulip_mii_writereg
- tulip_identify_dec_nic
- tulip_identify_znyx_nic
- tulip_identify_smc_nic
- tulip_identify_cogent_nic
- tulip_identify_accton_nic
- tulip_identify_asante_nic
- tulip_identify_compex_nic
- tulip_srom_decode
- tulip_read_macaddr
- tulip_ifmedia_add
- tulip_ifmedia_change
- tulip_ifmedia_status
- tulip_addr_filter
- tulip_reset
- tulip_init
- tulip_rx_intr
- tulip_tx_intr
- tulip_print_abnormal_interrupt
- tulip_intr_handler
- tulip_intr_shared
- tulip_intr_normal
- tulip_mbuf_compress
- tulip_txput
- tulip_txput_setup
- tulip_ifioctl
- tulip_ifstart
- tulip_ifstart_one
- tulip_ifwatchdog
- tulip_busdma_allocmem
- tulip_busdma_init
- tulip_initcsrs
- tulip_initring
- tulip_probe
- tulip_shutdown
- tulip_attach
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/mbuf.h>
44 #include <sys/protosw.h>
45 #include <sys/socket.h>
46 #include <sys/ioctl.h>
47 #include <sys/errno.h>
48 #include <sys/malloc.h>
49 #include <sys/kernel.h>
50 #include <sys/proc.h>
51 #include <sys/device.h>
52 #include <sys/timeout.h>
53
54 #include <net/if.h>
55 #include <net/if_media.h>
56 #include <net/if_types.h>
57 #include <net/if_dl.h>
58 #include <net/route.h>
59 #include <net/netisr.h>
60
61 #include "bpfilter.h"
62 #if NBPFILTER > 0
63 #include <net/bpf.h>
64 #endif
65
66 #ifdef INET
67 #include <netinet/in.h>
68 #include <netinet/in_systm.h>
69 #include <netinet/in_var.h>
70 #include <netinet/ip.h>
71 #endif
72
73 #include <netinet/if_ether.h>
74
75 #include <machine/bus.h>
76 #include <machine/intr.h>
77 #include <dev/pci/pcireg.h>
78 #include <dev/pci/pcivar.h>
79 #include <dev/pci/pcidevs.h>
80 #include <dev/ic/dc21040reg.h>
81
82
83
84
85 #if defined(__i386__)
86 #define TULIP_IOMAPPED
87 #endif
88
89 #define TULIP_HZ 10
90
91 #define TULIP_SIAGEN_WATCHDOG 0
92
93 #define TULIP_GPR_CMDBITS (TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION|TULIP_CMD_SCRAMBLER|TULIP_CMD_TXTHRSHLDCTL)
94
95 #define EMIT do { TULIP_CSR_WRITE(sc, csr_srom_mii, csr); tulip_delay_300ns(sc); } while (0)
96 #define MII_EMIT do { TULIP_CSR_WRITE(sc, csr_srom_mii, csr); tulip_delay_300ns(sc); } while (0)
97
98 #define tulip_mchash(mca) (ether_crc32_le(mca, 6) & 0x1FF)
99 #define tulip_srom_crcok(databuf) ( \
100 ((ether_crc32_le(databuf, 126) & 0xFFFFU) ^ 0xFFFFU) == \
101 ((databuf)[126] | ((databuf)[127] << 8)))
102
103
104
105
106
107
108
109 #define PCI_CFID 0x00
110 #define PCI_CFCS 0x04
111 #define PCI_CFRV 0x08
112 #define PCI_CFLT 0x0c
113 #define PCI_CBIO 0x10
114 #define PCI_CBMA 0x14
115 #define PCI_CFIT 0x3c
116 #define PCI_CFDA 0x40
117
118 #define PCI_CONF_WRITE(r, v) pci_conf_write(pa->pa_pc, pa->pa_tag, (r), (v))
119 #define PCI_CONF_READ(r) pci_conf_read(pa->pa_pc, pa->pa_tag, (r))
120 #define PCI_GETBUSDEVINFO(sc) do { \
121 (sc)->tulip_pci_busno = parent; \
122 (sc)->tulip_pci_devno = pa->pa_device; \
123 } while (0)
124
125 #include <dev/pci/if_devar.h>
126
127
128
129
130
131
132 int tulip_probe(struct device *parent, void *match, void *aux);
133 void tulip_attach(struct device * const parent, struct device * const self, void * const aux);
134
135 struct cfattach de_ca = {
136 sizeof(tulip_softc_t), tulip_probe, tulip_attach
137 };
138
139 struct cfdriver de_cd = {
140 0, "de", DV_IFNET
141 };
142
143 void tulip_timeout_callback(void *arg);
144 void tulip_timeout(tulip_softc_t * const sc);
145 int tulip_txprobe(tulip_softc_t * const sc);
146 void tulip_media_set(tulip_softc_t * const sc, tulip_media_t media);
147 void tulip_linkup(tulip_softc_t * const sc, tulip_media_t media);
148 void tulip_media_print(tulip_softc_t * const sc);
149 tulip_link_status_t tulip_media_link_monitor(tulip_softc_t * const sc);
150 void tulip_media_poll(tulip_softc_t * const sc, tulip_mediapoll_event_t event);
151 void tulip_media_select(tulip_softc_t * const sc);
152
153 void tulip_21040_mediainfo_init(tulip_softc_t * const sc, tulip_media_t media);
154 void tulip_21040_media_probe(tulip_softc_t * const sc);
155 void tulip_21040_10baset_only_media_probe(tulip_softc_t * const sc);
156 void tulip_21040_10baset_only_media_select(tulip_softc_t * const sc);
157 void tulip_21040_auibnc_only_media_probe(tulip_softc_t * const sc);
158 void tulip_21040_auibnc_only_media_select(tulip_softc_t * const sc);
159
160 void tulip_21041_mediainfo_init(tulip_softc_t * const sc);
161 void tulip_21041_media_noprobe(tulip_softc_t * const sc);
162 void tulip_21041_media_probe(tulip_softc_t * const sc);
163 void tulip_21041_media_poll(tulip_softc_t * const sc, const tulip_mediapoll_event_t event);
164
165 tulip_media_t tulip_mii_phy_readspecific(tulip_softc_t * const sc);
166 unsigned tulip_mii_get_phyaddr(tulip_softc_t * const sc, unsigned offset);
167 int tulip_mii_map_abilities(tulip_softc_t * const sc, unsigned abilities);
168 void tulip_mii_autonegotiate(tulip_softc_t * const sc, const unsigned phyaddr);
169
170 void tulip_2114x_media_preset(tulip_softc_t * const sc);
171
172 void tulip_null_media_poll(tulip_softc_t * const sc, tulip_mediapoll_event_t event);
173
174 void tulip_21140_mediainit(tulip_softc_t * const sc, tulip_media_info_t * const mip,
175 tulip_media_t const media, unsigned gpdata, unsigned cmdmode);
176 void tulip_21140_evalboard_media_probe(tulip_softc_t * const sc);
177 void tulip_21140_accton_media_probe(tulip_softc_t * const sc);
178 void tulip_21140_smc9332_media_probe(tulip_softc_t * const sc);
179 void tulip_21140_cogent_em100_media_probe(tulip_softc_t * const sc);
180 void tulip_21140_znyx_zx34x_media_probe(tulip_softc_t * const sc);
181
182 void tulip_2114x_media_probe(tulip_softc_t * const sc);
183
184 void tulip_delay_300ns(tulip_softc_t * const sc);
185 void tulip_srom_idle(tulip_softc_t * const sc);
186 void tulip_srom_read(tulip_softc_t * const sc);
187 void tulip_mii_writebits(tulip_softc_t * const sc, unsigned data, unsigned bits);
188 void tulip_mii_turnaround(tulip_softc_t * const sc, unsigned cmd);
189 unsigned tulip_mii_readbits(tulip_softc_t * const sc);
190 unsigned tulip_mii_readreg(tulip_softc_t * const sc, unsigned devaddr, unsigned regno);
191 void tulip_mii_writereg(tulip_softc_t * const sc, unsigned devaddr, unsigned regno,
192 unsigned data);
193
194 void tulip_identify_dec_nic(tulip_softc_t * const sc);
195 void tulip_identify_znyx_nic(tulip_softc_t * const sc);
196 void tulip_identify_smc_nic(tulip_softc_t * const sc);
197 void tulip_identify_cogent_nic(tulip_softc_t * const sc);
198 void tulip_identify_accton_nic(tulip_softc_t * const sc);
199 void tulip_identify_asante_nic(tulip_softc_t * const sc);
200 void tulip_identify_compex_nic(tulip_softc_t * const sc);
201
202 int tulip_srom_decode(tulip_softc_t * const sc);
203 int tulip_read_macaddr(tulip_softc_t * const sc);
204 void tulip_ifmedia_add(tulip_softc_t * const sc);
205 int tulip_ifmedia_change(struct ifnet * const ifp);
206 void tulip_ifmedia_status(struct ifnet * const ifp, struct ifmediareq *req);
207 void tulip_addr_filter(tulip_softc_t * const sc);
208 void tulip_reset(tulip_softc_t * const sc);
209 void tulip_init(tulip_softc_t * const sc);
210 void tulip_rx_intr(tulip_softc_t * const sc);
211 int tulip_tx_intr(tulip_softc_t * const sc);
212 void tulip_print_abnormal_interrupt(tulip_softc_t * const sc, u_int32_t csr);
213 void tulip_intr_handler(tulip_softc_t * const sc, int *progress_p);
214 int tulip_intr_shared(void *arg);
215 int tulip_intr_normal(void *arg);
216 struct mbuf *tulip_mbuf_compress(struct mbuf *m);
217 struct mbuf *tulip_txput(tulip_softc_t * const sc, struct mbuf *m);
218 void tulip_txput_setup(tulip_softc_t * const sc);
219 int tulip_ifioctl(struct ifnet * ifp, u_long cmd, caddr_t data);
220 void tulip_ifstart(struct ifnet *ifp);
221 void tulip_ifstart_one(struct ifnet *ifp);
222 void tulip_ifwatchdog(struct ifnet *ifp);
223 int tulip_busdma_allocmem(tulip_softc_t * const sc, size_t size,
224 bus_dmamap_t *map_p, tulip_desc_t **desc_p);
225 int tulip_busdma_init(tulip_softc_t * const sc);
226 void tulip_initcsrs(tulip_softc_t * const sc, bus_addr_t csr_base, size_t csr_size);
227 void tulip_initring(tulip_softc_t * const sc, tulip_ringinfo_t * const ri,
228 tulip_desc_t *descs, int ndescs);
229 void tulip_shutdown(void *arg);
230
231
232 void
233 tulip_timeout_callback(void *arg)
234 {
235 tulip_softc_t * const sc = arg;
236 int s;
237
238 s = splnet();
239
240 TULIP_PERFSTART(timeout)
241
242 sc->tulip_flags &= ~TULIP_TIMEOUTPENDING;
243 sc->tulip_probe_timeout -= 1000 / TULIP_HZ;
244 (sc->tulip_boardsw->bd_media_poll)(sc, TULIP_MEDIAPOLL_TIMER);
245
246 TULIP_PERFEND(timeout);
247 splx(s);
248 }
249
250 void
251 tulip_timeout(tulip_softc_t * const sc)
252 {
253 if (sc->tulip_flags & TULIP_TIMEOUTPENDING)
254 return;
255 sc->tulip_flags |= TULIP_TIMEOUTPENDING;
256 timeout_add(&sc->tulip_stmo, (hz + TULIP_HZ / 2) / TULIP_HZ);
257 }
258
259 int
260 tulip_txprobe(tulip_softc_t * const sc)
261 {
262 struct mbuf *m;
263
264
265
266
267
268
269
270
271 MGETHDR(m, M_DONTWAIT, MT_DATA);
272 if (m == NULL)
273 return (0);
274
275
276
277 bcopy(sc->tulip_enaddr, mtod(m, struct ether_header *)->ether_dhost,
278 ETHER_ADDR_LEN);
279 bcopy(sc->tulip_enaddr, mtod(m, struct ether_header *)->ether_shost,
280 ETHER_ADDR_LEN);
281 mtod(m, struct ether_header *)->ether_type = htons(3);
282 mtod(m, unsigned char *)[14] = 0;
283 mtod(m, unsigned char *)[15] = 0;
284 mtod(m, unsigned char *)[16] = 0xE3;
285 m->m_len = m->m_pkthdr.len = sizeof(struct ether_header) + 3;
286
287
288
289 sc->tulip_cmdmode |= TULIP_CMD_TXRUN;
290 sc->tulip_intrmask |= TULIP_STS_TXINTR;
291 sc->tulip_flags |= TULIP_TXPROBE_ACTIVE;
292 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
293 TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
294 if ((m = tulip_txput(sc, m)) != NULL)
295 m_freem(m);
296 sc->tulip_probe.probe_txprobes++;
297 return (1);
298 }
299
300 void
301 tulip_media_set(tulip_softc_t * const sc, tulip_media_t media)
302 {
303 const tulip_media_info_t *mi = sc->tulip_mediums[media];
304
305 if (mi == NULL)
306 return;
307
308
309
310 if (mi->mi_type == TULIP_MEDIAINFO_SIA || (sc->tulip_features & TULIP_HAVE_SIANWAY))
311 TULIP_CSR_WRITE(sc, csr_sia_connectivity, TULIP_SIACONN_RESET);
312
313
314
315 if (sc->tulip_flags & TULIP_FULLDUPLEX) {
316 #ifdef TULIP_DEBUG
317 if (TULIP_CSR_READ(sc, csr_command) & (TULIP_CMD_RXRUN|TULIP_CMD_TXRUN))
318 printf(TULIP_PRINTF_FMT ": warning: board is running (FD).\n", TULIP_PRINTF_ARGS);
319 if ((TULIP_CSR_READ(sc, csr_command) & TULIP_CMD_FULLDUPLEX) == 0)
320 printf(TULIP_PRINTF_FMT ": setting full duplex.\n", TULIP_PRINTF_ARGS);
321 TULIP_PRINTF_ARGS);
322 #endif
323 sc->tulip_cmdmode |= TULIP_CMD_FULLDUPLEX;
324 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode & ~(TULIP_CMD_RXRUN|TULIP_CMD_TXRUN));
325 }
326
327
328
329
330
331
332 sc->tulip_flags &= ~TULIP_RXACT;
333 if (mi->mi_type == TULIP_MEDIAINFO_SIA) {
334 TULIP_CSR_WRITE(sc, csr_sia_tx_rx, mi->mi_sia_tx_rx);
335 if (sc->tulip_features & TULIP_HAVE_SIAGP) {
336 TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_sia_gp_control|mi->mi_sia_general|TULIP_SIAGEN_WATCHDOG);
337 DELAY(50);
338 TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_sia_gp_data|mi->mi_sia_general|TULIP_SIAGEN_WATCHDOG);
339 } else
340 TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_sia_general|TULIP_SIAGEN_WATCHDOG);
341 TULIP_CSR_WRITE(sc, csr_sia_connectivity, mi->mi_sia_connectivity);
342 } else if (mi->mi_type == TULIP_MEDIAINFO_GPR) {
343
344
345
346
347 if (((mi->mi_cmdmode ^ TULIP_CSR_READ(sc, csr_command)) & TULIP_GPR_CMDBITS) != 0) {
348 sc->tulip_cmdmode &= ~TULIP_GPR_CMDBITS;
349 sc->tulip_cmdmode |= mi->mi_cmdmode;
350 tulip_reset(sc);
351 }
352 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_PINSET|sc->tulip_gpinit);
353 DELAY(10);
354 TULIP_CSR_WRITE(sc, csr_gp, (u_int8_t) mi->mi_gpdata);
355 } else if (mi->mi_type == TULIP_MEDIAINFO_SYM) {
356
357
358
359
360 if (((mi->mi_cmdmode ^ TULIP_CSR_READ(sc, csr_command)) & TULIP_GPR_CMDBITS) != 0) {
361 sc->tulip_cmdmode &= ~TULIP_GPR_CMDBITS;
362 sc->tulip_cmdmode |= mi->mi_cmdmode;
363 tulip_reset(sc);
364 }
365 TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_gpcontrol);
366 TULIP_CSR_WRITE(sc, csr_sia_general, mi->mi_gpdata);
367 } else if (mi->mi_type == TULIP_MEDIAINFO_MII
368 && sc->tulip_probe_state != TULIP_PROBE_INACTIVE) {
369 int idx;
370 if (sc->tulip_features & TULIP_HAVE_SIAGP) {
371 const u_int8_t *dp;
372 dp = &sc->tulip_rombuf[mi->mi_reset_offset];
373 for (idx = 0; idx < mi->mi_reset_length; idx++, dp += 2) {
374 DELAY(10);
375 TULIP_CSR_WRITE(sc, csr_sia_general, (dp[0] + 256 * dp[1]) << 16);
376 }
377 sc->tulip_phyaddr = mi->mi_phyaddr;
378 dp = &sc->tulip_rombuf[mi->mi_gpr_offset];
379 for (idx = 0; idx < mi->mi_gpr_length; idx++, dp += 2) {
380 DELAY(10);
381 TULIP_CSR_WRITE(sc, csr_sia_general, (dp[0] + 256 * dp[1]) << 16);
382 }
383 } else {
384 for (idx = 0; idx < mi->mi_reset_length; idx++) {
385 DELAY(10);
386 TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_rombuf[mi->mi_reset_offset + idx]);
387 }
388 sc->tulip_phyaddr = mi->mi_phyaddr;
389 for (idx = 0; idx < mi->mi_gpr_length; idx++) {
390 DELAY(10);
391 TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_rombuf[mi->mi_gpr_offset + idx]);
392 }
393 }
394
395 if (sc->tulip_features & TULIP_HAVE_SIANWAY) {
396
397 TULIP_CSR_WRITE(sc, csr_sia_general, 1);
398 TULIP_CSR_WRITE(sc, csr_sia_tx_rx, 0);
399 TULIP_CSR_WRITE(sc, csr_sia_status, 0);
400 }
401
402 if (sc->tulip_flags & TULIP_TRYNWAY)
403 tulip_mii_autonegotiate(sc, sc->tulip_phyaddr);
404 else if ((sc->tulip_flags & TULIP_DIDNWAY) == 0) {
405 u_int32_t data = tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_CONTROL);
406 data &= ~(PHYCTL_SELECT_100MB|PHYCTL_FULL_DUPLEX|PHYCTL_AUTONEG_ENABLE);
407 sc->tulip_flags &= ~TULIP_DIDNWAY;
408 if (TULIP_IS_MEDIA_FD(media))
409 data |= PHYCTL_FULL_DUPLEX;
410 if (TULIP_IS_MEDIA_100MB(media))
411 data |= PHYCTL_SELECT_100MB;
412 tulip_mii_writereg(sc, sc->tulip_phyaddr, PHYREG_CONTROL, data);
413 }
414 }
415 }
416
417 void
418 tulip_linkup(tulip_softc_t * const sc, tulip_media_t media)
419 {
420 if ((sc->tulip_flags & TULIP_LINKUP) == 0)
421 sc->tulip_flags |= TULIP_PRINTLINKUP;
422 sc->tulip_flags |= TULIP_LINKUP;
423 sc->tulip_if.if_flags &= ~IFF_OACTIVE;
424 if (sc->tulip_media != media) {
425 #ifdef TULIP_DEBUG
426 sc->tulip_dbg.dbg_last_media = sc->tulip_media;
427 #endif
428 sc->tulip_media = media;
429 sc->tulip_flags |= TULIP_PRINTMEDIA;
430 if (TULIP_IS_MEDIA_FD(sc->tulip_media))
431 sc->tulip_flags |= TULIP_FULLDUPLEX;
432 else if (sc->tulip_chipid != TULIP_21041 || (sc->tulip_flags & TULIP_DIDNWAY) == 0)
433 sc->tulip_flags &= ~TULIP_FULLDUPLEX;
434 }
435
436
437
438
439
440
441 sc->tulip_probe_timeout = 3000;
442 sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
443 sc->tulip_flags &= ~(TULIP_TXPROBE_ACTIVE|TULIP_TRYNWAY);
444 if (sc->tulip_flags & TULIP_INRESET)
445 tulip_media_set(sc, sc->tulip_media);
446 else if (sc->tulip_probe_media != sc->tulip_media) {
447
448
449
450 tulip_reset(sc);
451 }
452 tulip_init(sc);
453 }
454
455 void
456 tulip_media_print(tulip_softc_t * const sc)
457 {
458 if ((sc->tulip_flags & TULIP_LINKUP) == 0)
459 return;
460 if (sc->tulip_flags & TULIP_PRINTMEDIA) {
461 #ifdef TULIP_DEBUG
462 printf(TULIP_PRINTF_FMT ": enabling %s port\n",
463 TULIP_PRINTF_ARGS,
464 tulip_mediums[sc->tulip_media]);
465 #endif
466 sc->tulip_flags &= ~(TULIP_PRINTMEDIA|TULIP_PRINTLINKUP);
467 } else if (sc->tulip_flags & TULIP_PRINTLINKUP) {
468 #ifdef TULIP_DEBUG
469 printf(TULIP_PRINTF_FMT ": link up\n", TULIP_PRINTF_ARGS);
470 #endif
471 sc->tulip_flags &= ~TULIP_PRINTLINKUP;
472 }
473 }
474
475 tulip_link_status_t
476 tulip_media_link_monitor(tulip_softc_t * const sc)
477 {
478 const tulip_media_info_t * const mi = sc->tulip_mediums[sc->tulip_media];
479 tulip_link_status_t linkup = TULIP_LINK_DOWN;
480
481 if (mi == NULL) {
482 #if defined(TULIP_DEBUG)
483 printf("tulip_media_link_monitor: %s: botch at line %d\n",
484 tulip_mediums[sc->tulip_media],__LINE__);
485 #endif
486 return (TULIP_LINK_UNKNOWN);
487 }
488
489
490
491
492
493 if ((sc->tulip_flags & (TULIP_RXACT|TULIP_LINKUP)) == (TULIP_RXACT|TULIP_LINKUP)) {
494 sc->tulip_flags &= ~TULIP_RXACT;
495 sc->tulip_probe_timeout = 3000;
496 return (TULIP_LINK_UP);
497 }
498
499 sc->tulip_flags &= ~TULIP_RXACT;
500 if (mi->mi_type == TULIP_MEDIAINFO_MII) {
501 u_int32_t status;
502
503
504
505 status = tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_STATUS)
506 | tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_STATUS);
507 if (status & PHYSTS_AUTONEG_DONE) {
508
509
510
511
512
513 u_int32_t abilities = tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_AUTONEG_ABILITIES);
514 abilities = (abilities << 6) & status;
515 if (abilities != sc->tulip_abilities) {
516 #if defined(TULIP_DEBUG)
517 printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation changed: 0x%04x -> 0x%04x\n",
518 TULIP_PRINTF_ARGS, sc->tulip_phyaddr,
519 sc->tulip_abilities, abilities);
520 #endif
521 if (tulip_mii_map_abilities(sc, abilities)) {
522 tulip_linkup(sc, sc->tulip_probe_media);
523 return (TULIP_LINK_UP);
524 }
525
526
527
528
529 sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
530 if (sc->tulip_flags & TULIP_DIDNWAY)
531 return (TULIP_LINK_DOWN);
532 }
533 }
534
535
536
537 if ((status & (PHYSTS_LINK_UP|PHYSTS_REMOTE_FAULT)) == PHYSTS_LINK_UP)
538 linkup = TULIP_LINK_UP;
539 } else if (mi->mi_type == TULIP_MEDIAINFO_GPR) {
540
541
542
543 if (mi->mi_actmask == 0)
544 return (TULIP_LINK_UNKNOWN);
545
546
547
548 if ((TULIP_CSR_READ(sc, csr_gp) & mi->mi_actmask) == mi->mi_actdata)
549 linkup = TULIP_LINK_UP;
550 } else if (mi->mi_type == TULIP_MEDIAINFO_SIA) {
551
552
553
554 if (!TULIP_IS_MEDIA_TP(sc->tulip_media))
555 return (TULIP_LINK_UNKNOWN);
556 if ((TULIP_CSR_READ(sc, csr_sia_status) & TULIP_SIASTS_LINKFAIL) == 0)
557 linkup = TULIP_LINK_UP;
558 #if defined(TULIP_DEBUG)
559 if (sc->tulip_probe_timeout <= 0)
560 printf(TULIP_PRINTF_FMT ": sia status = 0x%08x\n", TULIP_PRINTF_ARGS, TULIP_CSR_READ(sc, csr_sia_status));
561 #endif
562 } else if (mi->mi_type == TULIP_MEDIAINFO_SYM)
563 return (TULIP_LINK_UNKNOWN);
564
565
566
567 if (sc->tulip_flags & TULIP_LINKUP) {
568 if (linkup == TULIP_LINK_UP)
569 sc->tulip_probe_timeout = 3000;
570 if (sc->tulip_probe_timeout > 0)
571 return (TULIP_LINK_UP);
572
573 sc->tulip_flags &= ~TULIP_LINKUP;
574 }
575 #if defined(TULIP_DEBUG)
576 sc->tulip_dbg.dbg_link_downed++;
577 #endif
578 return (TULIP_LINK_DOWN);
579 }
580
581 void
582 tulip_media_poll(tulip_softc_t * const sc, tulip_mediapoll_event_t event)
583 {
584 #if defined(TULIP_DEBUG)
585 sc->tulip_dbg.dbg_events[event]++;
586 #endif
587 if (sc->tulip_probe_state == TULIP_PROBE_INACTIVE
588 && event == TULIP_MEDIAPOLL_TIMER) {
589 switch (tulip_media_link_monitor(sc)) {
590 case TULIP_LINK_DOWN: {
591
592
593
594 event = TULIP_MEDIAPOLL_LINKFAIL;
595 break;
596 }
597 case TULIP_LINK_UP: {
598
599
600
601 tulip_timeout(sc);
602 return;
603 }
604 case TULIP_LINK_UNKNOWN: {
605
606
607
608 return;
609 }
610 }
611 }
612
613 if (event == TULIP_MEDIAPOLL_LINKFAIL) {
614 if (sc->tulip_probe_state == TULIP_PROBE_INACTIVE) {
615 if (TULIP_DO_AUTOSENSE(sc)) {
616 #if defined(TULIP_DEBUG)
617 sc->tulip_dbg.dbg_link_failures++;
618 #endif
619 sc->tulip_media = TULIP_MEDIA_UNKNOWN;
620 if (sc->tulip_if.if_flags & IFF_UP)
621 tulip_reset(sc);
622 }
623 return;
624 }
625 #if defined(TULIP_DEBUG)
626 sc->tulip_dbg.dbg_link_pollintrs++;
627 #endif
628 }
629
630 if (event == TULIP_MEDIAPOLL_START) {
631 sc->tulip_if.if_flags |= IFF_OACTIVE;
632 if (sc->tulip_probe_state != TULIP_PROBE_INACTIVE)
633 return;
634 sc->tulip_probe_mediamask = 0;
635 sc->tulip_probe_passes = 0;
636 #if defined(TULIP_DEBUG)
637 sc->tulip_dbg.dbg_media_probes++;
638 #endif
639
640
641
642 sc->tulip_cmdmode &= ~(TULIP_CMD_RXRUN|TULIP_CMD_FULLDUPLEX);
643 sc->tulip_flags |= TULIP_TRYNWAY|TULIP_PROBE1STPASS;
644 sc->tulip_flags &= ~(TULIP_DIDNWAY|TULIP_PRINTMEDIA|TULIP_PRINTLINKUP);
645
646
647
648 sc->tulip_probe_media = tulip_srom_conninfo[sc->tulip_connidx].sc_media;
649 if (sc->tulip_probe_media != TULIP_MEDIA_UNKNOWN) {
650 tulip_linkup(sc, sc->tulip_probe_media);
651 tulip_timeout(sc);
652 return;
653 }
654
655 if (sc->tulip_features & TULIP_HAVE_GPR) {
656 sc->tulip_probe_state = TULIP_PROBE_GPRTEST;
657 sc->tulip_probe_timeout = 2000;
658 } else {
659 sc->tulip_probe_media = TULIP_MEDIA_MAX;
660 sc->tulip_probe_timeout = 0;
661 sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
662 }
663 }
664
665
666
667
668 if (event == TULIP_MEDIAPOLL_TXPROBE_FAILED
669 && sc->tulip_probe_state != TULIP_PROBE_MEDIATEST) {
670 sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
671 return;
672 }
673
674
675
676
677 if (event == TULIP_MEDIAPOLL_TXPROBE_OK || event == TULIP_MEDIAPOLL_LINKPASS) {
678 if (event == TULIP_MEDIAPOLL_LINKPASS) {
679
680 sc->tulip_probe_media = TULIP_MEDIA_10BASET;
681 #if defined(TULIP_DEBUG)
682 } else {
683 sc->tulip_dbg.dbg_txprobes_ok[sc->tulip_probe_media]++;
684 #endif
685 }
686 tulip_linkup(sc, sc->tulip_probe_media);
687 tulip_timeout(sc);
688 return;
689 }
690
691 if (sc->tulip_probe_state == TULIP_PROBE_GPRTEST) {
692
693
694
695
696 sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
697 sc->tulip_probe_media = TULIP_MEDIA_MAX;
698 sc->tulip_probe_timeout = 0;
699 tulip_timeout(sc);
700 return;
701 }
702
703 if (sc->tulip_probe_state != TULIP_PROBE_MEDIATEST
704 && (sc->tulip_features & TULIP_HAVE_MII)) {
705 tulip_media_t old_media = sc->tulip_probe_media;
706 tulip_mii_autonegotiate(sc, sc->tulip_phyaddr);
707 switch (sc->tulip_probe_state) {
708 case TULIP_PROBE_FAILED:
709 case TULIP_PROBE_MEDIATEST: {
710
711
712
713 sc->tulip_probe_mediamask |= sc->tulip_mediums[sc->tulip_probe_media]->mi_mediamask;
714 sc->tulip_probe_timeout = 0;
715 break;
716 }
717 case TULIP_PROBE_PHYAUTONEG: {
718 return;
719 }
720 case TULIP_PROBE_INACTIVE: {
721
722
723
724 sc->tulip_probe_timeout = 0;
725 if (sc->tulip_probe_mediamask & TULIP_BIT(sc->tulip_probe_media)) {
726 sc->tulip_probe_media = old_media;
727 break;
728 }
729 tulip_linkup(sc, sc->tulip_probe_media);
730 tulip_timeout(sc);
731 return;
732 }
733 default: {
734 #if defined(DIAGNOSTIC) || defined(TULIP_DEBUG)
735 printf("tulip_media_poll: botch at line %d\n", __LINE__);
736 #endif
737 break;
738 }
739 }
740 }
741
742 if (event == TULIP_MEDIAPOLL_TXPROBE_FAILED) {
743 #if defined(TULIP_DEBUG)
744 sc->tulip_dbg.dbg_txprobes_failed[sc->tulip_probe_media]++;
745 #endif
746 sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
747 return;
748 }
749
750
751
752
753 if ( sc->tulip_probe_timeout <= 0) {
754 #if defined(TULIP_DEBUG)
755 if (sc->tulip_probe_media == TULIP_MEDIA_UNKNOWN) {
756 printf(TULIP_PRINTF_FMT ": poll media unknown!\n",
757 TULIP_PRINTF_ARGS);
758 sc->tulip_probe_media = TULIP_MEDIA_MAX;
759 }
760 #endif
761
762
763
764
765 do {
766 sc->tulip_probe_media -= 1;
767 if (sc->tulip_probe_media == TULIP_MEDIA_UNKNOWN) {
768 if (++sc->tulip_probe_passes == 3) {
769 if ((sc->tulip_if.if_flags & IFF_UP) == 0) {
770 sc->tulip_if.if_flags &= ~IFF_RUNNING;
771 sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
772 return;
773 }
774 }
775 sc->tulip_flags ^= TULIP_TRYNWAY;
776 sc->tulip_probe_mediamask = 0;
777 sc->tulip_probe_media = TULIP_MEDIA_MAX - 1;
778 }
779 } while (sc->tulip_mediums[sc->tulip_probe_media] == NULL
780 || (sc->tulip_probe_mediamask & TULIP_BIT(sc->tulip_probe_media))
781 || TULIP_IS_MEDIA_FD(sc->tulip_probe_media));
782
783 #if defined(TULIP_DEBUG)
784 printf(TULIP_PRINTF_FMT ": %s: probing %s\n", TULIP_PRINTF_ARGS,
785 event == TULIP_MEDIAPOLL_TXPROBE_FAILED ? "txprobe failed" : "timeout",
786 tulip_mediums[sc->tulip_probe_media]);
787 #endif
788 sc->tulip_probe_timeout = TULIP_IS_MEDIA_TP(sc->tulip_probe_media) ? 2500 : 1000;
789 sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
790 sc->tulip_probe.probe_txprobes = 0;
791 tulip_reset(sc);
792 tulip_media_set(sc, sc->tulip_probe_media);
793 sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
794 }
795 tulip_timeout(sc);
796
797
798
799
800
801
802 switch (sc->tulip_mediums[sc->tulip_probe_media]->mi_type) {
803 case TULIP_MEDIAINFO_MII: {
804 if (sc->tulip_probe_media != tulip_mii_phy_readspecific(sc))
805 return;
806 break;
807 }
808 case TULIP_MEDIAINFO_SIA: {
809 if (TULIP_IS_MEDIA_TP(sc->tulip_probe_media)) {
810 if (TULIP_CSR_READ(sc, csr_sia_status) & TULIP_SIASTS_LINKFAIL)
811 return;
812 tulip_linkup(sc, sc->tulip_probe_media);
813 return;
814 }
815 break;
816 }
817 case TULIP_MEDIAINFO_RESET:
818 case TULIP_MEDIAINFO_SYM:
819 case TULIP_MEDIAINFO_NONE:
820 case TULIP_MEDIAINFO_GPR: {
821 break;
822 }
823 }
824
825
826
827 tulip_txprobe(sc);
828 }
829
830 void
831 tulip_media_select(tulip_softc_t * const sc)
832 {
833 if (sc->tulip_features & TULIP_HAVE_GPR) {
834 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_PINSET|sc->tulip_gpinit);
835 DELAY(10);
836 TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_gpdata);
837 }
838
839
840
841 if (sc->tulip_features & TULIP_HAVE_NOMEDIA)
842 return;
843
844 if (sc->tulip_media == TULIP_MEDIA_UNKNOWN) {
845 TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
846 (*sc->tulip_boardsw->bd_media_poll)(sc, TULIP_MEDIAPOLL_START);
847 } else
848 tulip_media_set(sc, sc->tulip_media);
849 }
850
851 void
852 tulip_21040_mediainfo_init(tulip_softc_t * const sc, tulip_media_t media)
853 {
854 sc->tulip_cmdmode |= TULIP_CMD_CAPTREFFCT|TULIP_CMD_THRSHLD160
855 |TULIP_CMD_BACKOFFCTR;
856 sc->tulip_if.if_baudrate = 10000000;
857
858 if (media == TULIP_MEDIA_10BASET || media == TULIP_MEDIA_UNKNOWN) {
859 TULIP_MEDIAINFO_SIA_INIT(sc, &sc->tulip_mediainfo[0], 21040, 10BASET);
860 TULIP_MEDIAINFO_SIA_INIT(sc, &sc->tulip_mediainfo[1], 21040, 10BASET_FD);
861 sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
862 }
863
864 if (media == TULIP_MEDIA_AUIBNC || media == TULIP_MEDIA_UNKNOWN)
865 TULIP_MEDIAINFO_SIA_INIT(sc, &sc->tulip_mediainfo[2], 21040, AUIBNC);
866
867 if (media == TULIP_MEDIA_UNKNOWN)
868 TULIP_MEDIAINFO_SIA_INIT(sc, &sc->tulip_mediainfo[3], 21040, EXTSIA);
869 }
870
871 void
872 tulip_21040_media_probe(tulip_softc_t * const sc)
873 {
874 tulip_21040_mediainfo_init(sc, TULIP_MEDIA_UNKNOWN);
875 }
876
877 void
878 tulip_21040_10baset_only_media_probe(tulip_softc_t * const sc)
879 {
880 tulip_21040_mediainfo_init(sc, TULIP_MEDIA_10BASET);
881 tulip_media_set(sc, TULIP_MEDIA_10BASET);
882 sc->tulip_media = TULIP_MEDIA_10BASET;
883 }
884
885 void
886 tulip_21040_10baset_only_media_select(tulip_softc_t * const sc)
887 {
888 sc->tulip_flags |= TULIP_LINKUP;
889 if (sc->tulip_media == TULIP_MEDIA_10BASET_FD) {
890 sc->tulip_cmdmode |= TULIP_CMD_FULLDUPLEX;
891 sc->tulip_flags &= ~TULIP_SQETEST;
892 } else {
893 sc->tulip_cmdmode &= ~TULIP_CMD_FULLDUPLEX;
894 sc->tulip_flags |= TULIP_SQETEST;
895 }
896 tulip_media_set(sc, sc->tulip_media);
897 }
898
899 void
900 tulip_21040_auibnc_only_media_probe(tulip_softc_t * const sc)
901 {
902 tulip_21040_mediainfo_init(sc, TULIP_MEDIA_AUIBNC);
903 sc->tulip_flags |= TULIP_SQETEST|TULIP_LINKUP;
904 tulip_media_set(sc, TULIP_MEDIA_AUIBNC);
905 sc->tulip_media = TULIP_MEDIA_AUIBNC;
906 }
907
908 void
909 tulip_21040_auibnc_only_media_select(tulip_softc_t * const sc)
910 {
911 tulip_media_set(sc, TULIP_MEDIA_AUIBNC);
912 sc->tulip_cmdmode &= ~TULIP_CMD_FULLDUPLEX;
913 }
914
915 static const tulip_boardsw_t tulip_21040_boardsw = {
916 TULIP_21040_GENERIC,
917 tulip_21040_media_probe,
918 tulip_media_select,
919 tulip_media_poll,
920 };
921
922 static const tulip_boardsw_t tulip_21040_10baset_only_boardsw = {
923 TULIP_21040_GENERIC,
924 tulip_21040_10baset_only_media_probe,
925 tulip_21040_10baset_only_media_select,
926 NULL,
927 };
928
929 static const tulip_boardsw_t tulip_21040_auibnc_only_boardsw = {
930 TULIP_21040_GENERIC,
931 tulip_21040_auibnc_only_media_probe,
932 tulip_21040_auibnc_only_media_select,
933 NULL,
934 };
935
936 void
937 tulip_21041_mediainfo_init(tulip_softc_t * const sc)
938 {
939 tulip_media_info_t * const mi = sc->tulip_mediainfo;
940
941 TULIP_MEDIAINFO_SIA_INIT(sc, &mi[0], 21041, 10BASET);
942 TULIP_MEDIAINFO_SIA_INIT(sc, &mi[1], 21041, 10BASET_FD);
943 TULIP_MEDIAINFO_SIA_INIT(sc, &mi[2], 21041, AUI);
944 TULIP_MEDIAINFO_SIA_INIT(sc, &mi[3], 21041, BNC);
945 }
946
947 void
948 tulip_21041_media_noprobe(tulip_softc_t * const sc)
949 {
950 sc->tulip_if.if_baudrate = 10000000;
951 sc->tulip_cmdmode |= TULIP_CMD_CAPTREFFCT|TULIP_CMD_ENHCAPTEFFCT
952 |TULIP_CMD_THRSHLD160|TULIP_CMD_BACKOFFCTR;
953 sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
954 }
955
956 void
957 tulip_21041_media_probe(tulip_softc_t * const sc)
958 {
959 sc->tulip_if.if_baudrate = 10000000;
960 sc->tulip_cmdmode |= TULIP_CMD_CAPTREFFCT|TULIP_CMD_ENHCAPTEFFCT
961 |TULIP_CMD_THRSHLD160|TULIP_CMD_BACKOFFCTR;
962 sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
963 tulip_21041_mediainfo_init(sc);
964 }
965
966 void
967 tulip_21041_media_poll(tulip_softc_t * const sc, const tulip_mediapoll_event_t event)
968 {
969 u_int32_t sia_status;
970
971 #if defined(TULIP_DEBUG)
972 sc->tulip_dbg.dbg_events[event]++;
973 #endif
974
975 if (event == TULIP_MEDIAPOLL_LINKFAIL) {
976 if (sc->tulip_probe_state != TULIP_PROBE_INACTIVE
977 || !TULIP_DO_AUTOSENSE(sc))
978 return;
979 sc->tulip_media = TULIP_MEDIA_UNKNOWN;
980 tulip_reset(sc);
981 return;
982 }
983
984
985
986
987
988 if (event == TULIP_MEDIAPOLL_START) {
989 sc->tulip_if.if_flags |= IFF_OACTIVE;
990 sc->tulip_cmdmode &= ~(TULIP_CMD_FULLDUPLEX|TULIP_CMD_RXRUN);
991 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
992 sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
993 sc->tulip_probe_media = TULIP_MEDIA_10BASET;
994 sc->tulip_probe_timeout = TULIP_21041_PROBE_10BASET_TIMEOUT;
995 tulip_media_set(sc, TULIP_MEDIA_10BASET);
996 tulip_timeout(sc);
997 return;
998 }
999
1000 if (sc->tulip_probe_state == TULIP_PROBE_INACTIVE)
1001 return;
1002
1003 if (event == TULIP_MEDIAPOLL_TXPROBE_OK) {
1004 #if defined(TULIP_DEBUG)
1005 sc->tulip_dbg.dbg_txprobes_ok[sc->tulip_probe_media]++;
1006 #endif
1007 tulip_linkup(sc, sc->tulip_probe_media);
1008 return;
1009 }
1010
1011 sia_status = TULIP_CSR_READ(sc, csr_sia_status);
1012 TULIP_CSR_WRITE(sc, csr_sia_status, sia_status);
1013 if ((sia_status & TULIP_SIASTS_LINKFAIL) == 0) {
1014 if (sc->tulip_revinfo >= 0x20) {
1015 if (sia_status & (PHYSTS_10BASET_FD << (16 - 6)))
1016 sc->tulip_probe_media = TULIP_MEDIA_10BASET_FD;
1017 }
1018
1019
1020
1021
1022 tulip_linkup(sc, sc->tulip_probe_media);
1023 return;
1024 }
1025
1026
1027
1028
1029
1030
1031 if (sc->tulip_probe_media == TULIP_MEDIA_10BASET) {
1032 if (event != TULIP_MEDIAPOLL_TIMER)
1033 return;
1034 if (sc->tulip_probe_timeout > 0
1035 && (sia_status & TULIP_SIASTS_OTHERRXACTIVITY) == 0) {
1036 tulip_timeout(sc);
1037 return;
1038 }
1039 sc->tulip_probe_timeout = TULIP_21041_PROBE_AUIBNC_TIMEOUT;
1040 sc->tulip_flags |= TULIP_WANTRXACT;
1041 if (sia_status & TULIP_SIASTS_OTHERRXACTIVITY)
1042 sc->tulip_probe_media = TULIP_MEDIA_BNC;
1043 else
1044 sc->tulip_probe_media = TULIP_MEDIA_AUI;
1045 tulip_media_set(sc, sc->tulip_probe_media);
1046 tulip_timeout(sc);
1047 return;
1048 }
1049
1050
1051
1052
1053 if (event == TULIP_MEDIAPOLL_TXPROBE_FAILED)
1054 sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
1055
1056
1057 if (event == TULIP_MEDIAPOLL_TIMER) {
1058
1059
1060
1061 if (sc->tulip_flags & TULIP_RXACT) {
1062 tulip_linkup(sc, sc->tulip_probe_media);
1063 return;
1064 }
1065
1066
1067
1068 if ((sc->tulip_flags & TULIP_TXPROBE_ACTIVE) == 0
1069 && ((sc->tulip_flags & TULIP_WANTRXACT) == 0
1070 || (sia_status & TULIP_SIASTS_RXACTIVITY))) {
1071 sc->tulip_probe_timeout = TULIP_21041_PROBE_AUIBNC_TIMEOUT;
1072 tulip_txprobe(sc);
1073 tulip_timeout(sc);
1074 return;
1075 }
1076
1077
1078
1079
1080
1081 if (sc->tulip_probe_timeout <= 0) {
1082 if (sc->tulip_flags & TULIP_WANTRXACT) {
1083 sc->tulip_flags &= ~TULIP_WANTRXACT;
1084 sc->tulip_probe_timeout = TULIP_21041_PROBE_AUIBNC_TIMEOUT;
1085 } else {
1086 if ((sc->tulip_if.if_flags & IFF_UP) == 0) {
1087 sc->tulip_if.if_flags &= ~IFF_RUNNING;
1088 sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
1089 return;
1090 }
1091 }
1092 }
1093 }
1094
1095
1096
1097
1098 sc->tulip_probe_timeout = TULIP_21041_PROBE_AUIBNC_TIMEOUT;
1099 if (sc->tulip_probe_media == TULIP_MEDIA_AUI)
1100 sc->tulip_probe_media = TULIP_MEDIA_BNC;
1101 else
1102 sc->tulip_probe_media = TULIP_MEDIA_AUI;
1103 tulip_media_set(sc, sc->tulip_probe_media);
1104 sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
1105 tulip_timeout(sc);
1106 }
1107
1108 static const tulip_boardsw_t tulip_21041_boardsw = {
1109 TULIP_21041_GENERIC,
1110 tulip_21041_media_probe,
1111 tulip_media_select,
1112 tulip_21041_media_poll
1113 };
1114
1115 static const tulip_boardsw_t tulip_21041np_boardsw = {
1116 TULIP_21041_GENERIC,
1117 tulip_21041_media_noprobe,
1118 tulip_media_select,
1119 tulip_21041_media_poll
1120 };
1121
1122 static const tulip_phy_attr_t tulip_mii_phy_attrlist[] = {
1123 { 0x20005c00, 0,
1124 {
1125 { 0x19, 0x0040, 0x0040 },
1126 { 0x19, 0x0040, 0x0000 },
1127 },
1128 #if defined(TULIP_DEBUG)
1129 "NS DP83840",
1130 #endif
1131 },
1132 { 0x0281F400, 0,
1133 {
1134 { 0x12, 0x0010, 0x0000 },
1135 { 0 },
1136 { 0x12, 0x0010, 0x0010 },
1137 { 0x12, 0x0008, 0x0008 },
1138 },
1139 #if defined(TULIP_DEBUG)
1140 "Seeq 80C240"
1141 #endif
1142 },
1143 { 0x0281F400, 3,
1144 {
1145 { 0x12, 0x0080, 0x0000 },
1146 { 0x12, 0x0080, 0x0080 },
1147 { 0 },
1148 { 0x12, 0x0040, 0x0040 },
1149 },
1150 #if defined(TULIP_DEBUG)
1151 "Seeq 80225"
1152 #endif
1153 },
1154 { 0x0281F400, 0,
1155 {
1156 { 0x11, 0x8000, 0x0000 },
1157 { 0x11, 0x8000, 0x8000 },
1158 { 0 },
1159 { 0x11, 0x4000, 0x4000 },
1160 },
1161 #if defined(TULIP_DEBUG)
1162 "ICS 1890"
1163 #endif
1164 },
1165 { 0x78100000, 0,
1166 {
1167 { 0x14, 0x0800, 0x0000 },
1168 { 0x14, 0x0800, 0x0800 },
1169 { 0 },
1170 { 0x14, 0x1000, 0x1000 },
1171 },
1172 #if defined(TULIP_DEBUG)
1173 "LEVEL1 LXT970"
1174 #endif
1175 },
1176 { 0 }
1177 };
1178
1179 tulip_media_t
1180 tulip_mii_phy_readspecific(tulip_softc_t * const sc)
1181 {
1182 const tulip_phy_attr_t *attr;
1183 u_int16_t data;
1184 u_int32_t id;
1185 unsigned idx = 0;
1186 static const tulip_media_t table[] = {
1187 TULIP_MEDIA_UNKNOWN,
1188 TULIP_MEDIA_10BASET,
1189 TULIP_MEDIA_100BASETX,
1190 TULIP_MEDIA_100BASET4,
1191 TULIP_MEDIA_UNKNOWN,
1192 TULIP_MEDIA_10BASET_FD,
1193 TULIP_MEDIA_100BASETX_FD,
1194 TULIP_MEDIA_UNKNOWN
1195 };
1196
1197
1198
1199
1200 data = tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_STATUS)
1201 | tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_STATUS);
1202 if ((data & (PHYSTS_LINK_UP|PHYSTS_EXTENDED_REGS)) != (PHYSTS_LINK_UP|PHYSTS_EXTENDED_REGS))
1203 return (TULIP_MEDIA_UNKNOWN);
1204
1205 id = (tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_IDLOW) << 16) |
1206 tulip_mii_readreg(sc, sc->tulip_phyaddr, PHYREG_IDHIGH);
1207 for (attr = tulip_mii_phy_attrlist;; attr++) {
1208 if (attr->attr_id == 0)
1209 return (TULIP_MEDIA_UNKNOWN);
1210 if ((id & ~0x0F) == attr->attr_id)
1211 break;
1212 }
1213
1214 if (attr->attr_modes[PHY_MODE_100TX].pm_regno) {
1215 const tulip_phy_modedata_t * const pm = &attr->attr_modes[PHY_MODE_100TX];
1216 data = tulip_mii_readreg(sc, sc->tulip_phyaddr, pm->pm_regno);
1217 if ((data & pm->pm_mask) == pm->pm_value)
1218 idx = 2;
1219 }
1220 if (idx == 0 && attr->attr_modes[PHY_MODE_100T4].pm_regno) {
1221 const tulip_phy_modedata_t * const pm = &attr->attr_modes[PHY_MODE_100T4];
1222 data = tulip_mii_readreg(sc, sc->tulip_phyaddr, pm->pm_regno);
1223 if ((data & pm->pm_mask) == pm->pm_value)
1224 idx = 3;
1225 }
1226 if (idx == 0 && attr->attr_modes[PHY_MODE_10T].pm_regno) {
1227 const tulip_phy_modedata_t * const pm = &attr->attr_modes[PHY_MODE_10T];
1228 data = tulip_mii_readreg(sc, sc->tulip_phyaddr, pm->pm_regno);
1229 if ((data & pm->pm_mask) == pm->pm_value)
1230 idx = 1;
1231 }
1232 if (idx != 0 && attr->attr_modes[PHY_MODE_FULLDUPLEX].pm_regno) {
1233 const tulip_phy_modedata_t * const pm = &attr->attr_modes[PHY_MODE_FULLDUPLEX];
1234 data = tulip_mii_readreg(sc, sc->tulip_phyaddr, pm->pm_regno);
1235 idx += ((data & pm->pm_mask) == pm->pm_value ? 4 : 0);
1236 }
1237 return (table[idx]);
1238 }
1239
1240 unsigned
1241 tulip_mii_get_phyaddr(tulip_softc_t * const sc, unsigned offset)
1242 {
1243 unsigned phyaddr;
1244
1245 for (phyaddr = 1; phyaddr < 32; phyaddr++) {
1246 unsigned status = tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS);
1247 if (status == 0 || status == 0xFFFF || status < PHYSTS_10BASET)
1248 continue;
1249 if (offset == 0)
1250 return (phyaddr);
1251 offset--;
1252 }
1253 if (offset == 0) {
1254 unsigned status = tulip_mii_readreg(sc, 0, PHYREG_STATUS);
1255 if (status == 0 || status == 0xFFFF || status < PHYSTS_10BASET)
1256 return (TULIP_MII_NOPHY);
1257 return (0);
1258 }
1259 return (TULIP_MII_NOPHY);
1260 }
1261
1262 int
1263 tulip_mii_map_abilities(tulip_softc_t * const sc, unsigned abilities)
1264 {
1265 sc->tulip_abilities = abilities;
1266 if (abilities & PHYSTS_100BASETX_FD)
1267 sc->tulip_probe_media = TULIP_MEDIA_100BASETX_FD;
1268 else if (abilities & PHYSTS_100BASET4)
1269 sc->tulip_probe_media = TULIP_MEDIA_100BASET4;
1270 else if (abilities & PHYSTS_100BASETX)
1271 sc->tulip_probe_media = TULIP_MEDIA_100BASETX;
1272 else if (abilities & PHYSTS_10BASET_FD)
1273 sc->tulip_probe_media = TULIP_MEDIA_10BASET_FD;
1274 else if (abilities & PHYSTS_10BASET)
1275 sc->tulip_probe_media = TULIP_MEDIA_10BASET;
1276 else {
1277 sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
1278 return (0);
1279 }
1280 sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
1281 return (1);
1282 }
1283
1284 void
1285 tulip_mii_autonegotiate(tulip_softc_t * const sc, const unsigned phyaddr)
1286 {
1287 switch (sc->tulip_probe_state) {
1288 case TULIP_PROBE_MEDIATEST:
1289 case TULIP_PROBE_INACTIVE: {
1290 sc->tulip_flags |= TULIP_DIDNWAY;
1291 tulip_mii_writereg(sc, phyaddr, PHYREG_CONTROL, PHYCTL_RESET);
1292 sc->tulip_probe_timeout = 3000;
1293 sc->tulip_intrmask |= TULIP_STS_ABNRMLINTR|TULIP_STS_NORMALINTR;
1294 sc->tulip_probe_state = TULIP_PROBE_PHYRESET;
1295
1296 }
1297 case TULIP_PROBE_PHYRESET: {
1298 u_int32_t status;
1299 u_int32_t data = tulip_mii_readreg(sc, phyaddr, PHYREG_CONTROL);
1300 if (data & PHYCTL_RESET) {
1301 if (sc->tulip_probe_timeout > 0) {
1302 tulip_timeout(sc);
1303 return;
1304 }
1305 #ifdef TULIP_DEBUG
1306 printf(TULIP_PRINTF_FMT "(phy%d): error: reset of PHY never completed!\n",
1307 TULIP_PRINTF_ARGS, phyaddr);
1308 #endif
1309 sc->tulip_flags &= ~TULIP_TXPROBE_ACTIVE;
1310 sc->tulip_probe_state = TULIP_PROBE_FAILED;
1311 sc->tulip_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
1312 return;
1313 }
1314 status = tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS)
1315 | tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS);
1316 if ((status & PHYSTS_CAN_AUTONEG) == 0) {
1317 #if defined(TULIP_DEBUG)
1318 printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation disabled\n",
1319 TULIP_PRINTF_ARGS, phyaddr);
1320 #endif
1321 sc->tulip_flags &= ~TULIP_DIDNWAY;
1322 sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
1323 return;
1324 }
1325 if (tulip_mii_readreg(sc, phyaddr, PHYREG_AUTONEG_ADVERTISEMENT) != ((status >> 6) | 0x01))
1326 tulip_mii_writereg(sc, phyaddr, PHYREG_AUTONEG_ADVERTISEMENT, (status >> 6) | 0x01);
1327 tulip_mii_writereg(sc, phyaddr, PHYREG_CONTROL, data|PHYCTL_AUTONEG_RESTART|PHYCTL_AUTONEG_ENABLE);
1328 data = tulip_mii_readreg(sc, phyaddr, PHYREG_CONTROL);
1329 #if defined(TULIP_DEBUG)
1330 if ((data & PHYCTL_AUTONEG_ENABLE) == 0)
1331 printf(TULIP_PRINTF_FMT "(phy%d): oops: enable autonegotiation failed: 0x%04x\n",
1332 TULIP_PRINTF_ARGS, phyaddr, data);
1333 else
1334 printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation restarted: 0x%04x (ad=0x%04x)\n",
1335 TULIP_PRINTF_ARGS, phyaddr, data,
1336 tulip_mii_readreg(sc, phyaddr, PHYREG_AUTONEG_ADVERTISEMENT));
1337 sc->tulip_dbg.dbg_nway_starts++;
1338 #endif
1339 sc->tulip_probe_state = TULIP_PROBE_PHYAUTONEG;
1340 sc->tulip_probe_timeout = 3000;
1341
1342 }
1343 case TULIP_PROBE_PHYAUTONEG: {
1344 u_int32_t status = tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS)
1345 | tulip_mii_readreg(sc, phyaddr, PHYREG_STATUS);
1346 u_int32_t data;
1347 if ((status & PHYSTS_AUTONEG_DONE) == 0) {
1348 if (sc->tulip_probe_timeout > 0) {
1349 tulip_timeout(sc);
1350 return;
1351 }
1352 #if defined(TULIP_DEBUG)
1353 printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation timeout: sts=0x%04x, ctl=0x%04x\n",
1354 TULIP_PRINTF_ARGS, phyaddr, status,
1355 tulip_mii_readreg(sc, phyaddr, PHYREG_CONTROL));
1356 #endif
1357 sc->tulip_flags &= ~TULIP_DIDNWAY;
1358 sc->tulip_probe_state = TULIP_PROBE_MEDIATEST;
1359 return;
1360 }
1361 data = tulip_mii_readreg(sc, phyaddr, PHYREG_AUTONEG_ABILITIES)
1362 | tulip_mii_readreg(sc, phyaddr, PHYREG_AUTONEG_ABILITIES);
1363 #if defined(TULIP_DEBUG)
1364 printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation complete: 0x%04x (sts=0x%04x)\n",
1365 TULIP_PRINTF_ARGS, phyaddr, data, status);
1366 #endif
1367 data = (data << 6) & status;
1368 if (!tulip_mii_map_abilities(sc, data))
1369 sc->tulip_flags &= ~TULIP_DIDNWAY;
1370 return;
1371 }
1372 default: {
1373 #if defined(DIAGNOSTIC)
1374 printf("tulip_media_poll: botch at line %d\n", __LINE__);
1375 #endif
1376 break;
1377 }
1378 }
1379 #if defined(TULIP_DEBUG)
1380 printf(TULIP_PRINTF_FMT "(phy%d): autonegotiation failure: state = %d\n",
1381 TULIP_PRINTF_ARGS, phyaddr, sc->tulip_probe_state);
1382 sc->tulip_dbg.dbg_nway_failures++;
1383 #endif
1384 }
1385
1386 void
1387 tulip_2114x_media_preset(tulip_softc_t * const sc)
1388 {
1389 const tulip_media_info_t *mi = NULL;
1390 tulip_media_t media = sc->tulip_media;
1391
1392 if (sc->tulip_probe_state == TULIP_PROBE_INACTIVE)
1393 media = sc->tulip_media;
1394 else
1395 media = sc->tulip_probe_media;
1396
1397 sc->tulip_cmdmode &= ~(TULIP_CMD_PORTSELECT|TULIP_CMD_NOHEARTBEAT
1398 |TULIP_CMD_FULLDUPLEX|TULIP_CMD_TXTHRSHLDCTL);
1399 sc->tulip_flags &= ~(TULIP_SQETEST|TULIP_FULLDUPLEX);
1400 if (media != TULIP_MEDIA_UNKNOWN && media != TULIP_MEDIA_MAX) {
1401 #if defined(TULIP_DEBUG)
1402 if (media < TULIP_MEDIA_MAX && sc->tulip_mediums[media] != NULL) {
1403 #endif
1404 mi = sc->tulip_mediums[media];
1405 if (mi->mi_type == TULIP_MEDIAINFO_MII)
1406 sc->tulip_cmdmode |= TULIP_CMD_PORTSELECT;
1407 else if (mi->mi_type == TULIP_MEDIAINFO_GPR
1408 || mi->mi_type == TULIP_MEDIAINFO_SYM) {
1409 sc->tulip_cmdmode &= ~TULIP_GPR_CMDBITS;
1410 sc->tulip_cmdmode |= mi->mi_cmdmode;
1411 } else if (mi->mi_type == TULIP_MEDIAINFO_SIA)
1412 TULIP_CSR_WRITE(sc, csr_sia_connectivity, TULIP_SIACONN_RESET);
1413 #if defined(TULIP_DEBUG)
1414 } else {
1415 printf(TULIP_PRINTF_FMT ": preset: bad media %d!\n",
1416 TULIP_PRINTF_ARGS, media);
1417 }
1418 #endif
1419 }
1420 switch (media) {
1421 case TULIP_MEDIA_BNC:
1422 case TULIP_MEDIA_AUI:
1423 case TULIP_MEDIA_10BASET: {
1424 sc->tulip_cmdmode |= TULIP_CMD_TXTHRSHLDCTL;
1425 sc->tulip_if.if_baudrate = 10000000;
1426 sc->tulip_flags |= TULIP_SQETEST;
1427 break;
1428 }
1429 case TULIP_MEDIA_10BASET_FD: {
1430 sc->tulip_flags |= TULIP_FULLDUPLEX;
1431 sc->tulip_cmdmode |= TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX;
1432 sc->tulip_if.if_baudrate = 10000000;
1433 break;
1434 }
1435 case TULIP_MEDIA_100BASEFX:
1436 case TULIP_MEDIA_100BASET4:
1437 case TULIP_MEDIA_100BASETX: {
1438 sc->tulip_cmdmode |= TULIP_CMD_PORTSELECT;
1439 sc->tulip_if.if_baudrate = 100000000;
1440 if (mi->mi_type == TULIP_MEDIAINFO_SYM
1441 || mi->mi_type == TULIP_MEDIAINFO_MII) {
1442 sc->tulip_cmdmode |= TULIP_CMD_NOHEARTBEAT;
1443 }
1444 break;
1445 }
1446 case TULIP_MEDIA_100BASEFX_FD:
1447 case TULIP_MEDIA_100BASETX_FD: {
1448 sc->tulip_flags |= TULIP_FULLDUPLEX;
1449 sc->tulip_cmdmode |= TULIP_CMD_PORTSELECT|TULIP_CMD_FULLDUPLEX;
1450 sc->tulip_if.if_baudrate = 100000000;
1451 if (mi->mi_type == TULIP_MEDIAINFO_SYM
1452 || mi->mi_type == TULIP_MEDIAINFO_MII) {
1453 sc->tulip_cmdmode |= TULIP_CMD_NOHEARTBEAT;
1454 }
1455 break;
1456 }
1457 default: {
1458 break;
1459 }
1460 }
1461 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
1462 }
1463
1464
1465
1466
1467
1468
1469 void
1470 tulip_null_media_poll(tulip_softc_t * const sc, tulip_mediapoll_event_t event)
1471 {
1472 #if defined(TULIP_DEBUG)
1473 sc->tulip_dbg.dbg_events[event]++;
1474 #endif
1475 #if defined(DIAGNOSTIC)
1476 printf(TULIP_PRINTF_FMT ": botch(media_poll) at line %d\n",
1477 TULIP_PRINTF_ARGS, __LINE__);
1478 #endif
1479 }
1480
1481 void
1482 tulip_21140_mediainit(tulip_softc_t * const sc, tulip_media_info_t * const mip,
1483 tulip_media_t const media, unsigned gpdata, unsigned cmdmode)
1484 {
1485 sc->tulip_mediums[media] = mip;
1486 mip->mi_type = TULIP_MEDIAINFO_GPR;
1487 mip->mi_cmdmode = cmdmode;
1488 mip->mi_gpdata = gpdata;
1489 }
1490
1491 void
1492 tulip_21140_evalboard_media_probe(tulip_softc_t * const sc)
1493 {
1494 tulip_media_info_t *mip = sc->tulip_mediainfo;
1495
1496 sc->tulip_gpinit = TULIP_GP_EB_PINS;
1497 sc->tulip_gpdata = TULIP_GP_EB_INIT;
1498 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EB_PINS);
1499 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EB_INIT);
1500 TULIP_CSR_WRITE(sc, csr_command,
1501 TULIP_CSR_READ(sc, csr_command) | TULIP_CMD_PORTSELECT |
1502 TULIP_CMD_PCSFUNCTION | TULIP_CMD_SCRAMBLER | TULIP_CMD_MUSTBEONE);
1503 TULIP_CSR_WRITE(sc, csr_command,
1504 TULIP_CSR_READ(sc, csr_command) & ~TULIP_CMD_TXTHRSHLDCTL);
1505 DELAY(1000000);
1506 if ((TULIP_CSR_READ(sc, csr_gp) & TULIP_GP_EB_OK100) != 0)
1507 sc->tulip_media = TULIP_MEDIA_10BASET;
1508 else
1509 sc->tulip_media = TULIP_MEDIA_100BASETX;
1510 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET,
1511 TULIP_GP_EB_INIT,
1512 TULIP_CMD_TXTHRSHLDCTL);
1513 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET_FD,
1514 TULIP_GP_EB_INIT,
1515 TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX);
1516 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
1517 TULIP_GP_EB_INIT,
1518 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1519 |TULIP_CMD_SCRAMBLER);
1520 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
1521 TULIP_GP_EB_INIT,
1522 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1523 |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
1524 }
1525
1526 static const tulip_boardsw_t tulip_21140_eb_boardsw = {
1527 TULIP_21140_DEC_EB,
1528 tulip_21140_evalboard_media_probe,
1529 tulip_media_select,
1530 tulip_null_media_poll,
1531 tulip_2114x_media_preset,
1532 };
1533
1534 void
1535 tulip_21140_accton_media_probe(tulip_softc_t * const sc)
1536 {
1537 tulip_media_info_t *mip = sc->tulip_mediainfo;
1538 unsigned gpdata;
1539
1540 sc->tulip_gpinit = TULIP_GP_EB_PINS;
1541 sc->tulip_gpdata = TULIP_GP_EB_INIT;
1542 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EB_PINS);
1543 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EB_INIT);
1544 TULIP_CSR_WRITE(sc, csr_command,
1545 TULIP_CSR_READ(sc, csr_command) | TULIP_CMD_PORTSELECT |
1546 TULIP_CMD_PCSFUNCTION | TULIP_CMD_SCRAMBLER | TULIP_CMD_MUSTBEONE);
1547 TULIP_CSR_WRITE(sc, csr_command,
1548 TULIP_CSR_READ(sc, csr_command) & ~TULIP_CMD_TXTHRSHLDCTL);
1549 DELAY(1000000);
1550 gpdata = TULIP_CSR_READ(sc, csr_gp);
1551 if ((gpdata & TULIP_GP_EN1207_UTP_INIT) == 0)
1552 sc->tulip_media = TULIP_MEDIA_10BASET;
1553 else {
1554 if ((gpdata & TULIP_GP_EN1207_BNC_INIT) == 0)
1555 sc->tulip_media = TULIP_MEDIA_BNC;
1556 else
1557 sc->tulip_media = TULIP_MEDIA_100BASETX;
1558 }
1559 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_BNC,
1560 TULIP_GP_EN1207_BNC_INIT,
1561 TULIP_CMD_TXTHRSHLDCTL);
1562 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET,
1563 TULIP_GP_EN1207_UTP_INIT,
1564 TULIP_CMD_TXTHRSHLDCTL);
1565 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET_FD,
1566 TULIP_GP_EN1207_UTP_INIT,
1567 TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX);
1568 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
1569 TULIP_GP_EN1207_100_INIT,
1570 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1571 |TULIP_CMD_SCRAMBLER);
1572 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
1573 TULIP_GP_EN1207_100_INIT,
1574 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1575 |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
1576 }
1577
1578 static const tulip_boardsw_t tulip_21140_accton_boardsw = {
1579 TULIP_21140_EN1207,
1580 tulip_21140_accton_media_probe,
1581 tulip_media_select,
1582 tulip_null_media_poll,
1583 tulip_2114x_media_preset,
1584 };
1585
1586 void
1587 tulip_21140_smc9332_media_probe(tulip_softc_t * const sc)
1588 {
1589 tulip_media_info_t *mip = sc->tulip_mediainfo;
1590 int idx, cnt = 0;
1591
1592 TULIP_CSR_WRITE(sc, csr_command, TULIP_CMD_PORTSELECT|TULIP_CMD_MUSTBEONE);
1593 TULIP_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
1594 DELAY(10);
1595
1596
1597 TULIP_CSR_WRITE(sc, csr_command, TULIP_CMD_PORTSELECT |
1598 TULIP_CMD_PCSFUNCTION | TULIP_CMD_SCRAMBLER | TULIP_CMD_MUSTBEONE);
1599 sc->tulip_gpinit = TULIP_GP_SMC_9332_PINS;
1600 sc->tulip_gpdata = TULIP_GP_SMC_9332_INIT;
1601 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_SMC_9332_PINS|TULIP_GP_PINSET);
1602 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_SMC_9332_INIT);
1603 DELAY(200000);
1604 for (idx = 1000; idx > 0; idx--) {
1605 u_int32_t csr = TULIP_CSR_READ(sc, csr_gp);
1606 if ((csr & (TULIP_GP_SMC_9332_OK10|TULIP_GP_SMC_9332_OK100)) == (TULIP_GP_SMC_9332_OK10|TULIP_GP_SMC_9332_OK100)) {
1607 if (++cnt > 100)
1608 break;
1609 } else if ((csr & TULIP_GP_SMC_9332_OK10) == 0)
1610 break;
1611 else
1612 cnt = 0;
1613 DELAY(1000);
1614 }
1615 sc->tulip_media = cnt > 100 ? TULIP_MEDIA_100BASETX : TULIP_MEDIA_10BASET;
1616 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
1617 TULIP_GP_SMC_9332_INIT,
1618 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1619 |TULIP_CMD_SCRAMBLER);
1620 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
1621 TULIP_GP_SMC_9332_INIT,
1622 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1623 |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
1624 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET,
1625 TULIP_GP_SMC_9332_INIT,
1626 TULIP_CMD_TXTHRSHLDCTL);
1627 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET_FD,
1628 TULIP_GP_SMC_9332_INIT,
1629 TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX);
1630 }
1631
1632 static const tulip_boardsw_t tulip_21140_smc9332_boardsw = {
1633 TULIP_21140_SMC_9332,
1634 tulip_21140_smc9332_media_probe,
1635 tulip_media_select,
1636 tulip_null_media_poll,
1637 tulip_2114x_media_preset,
1638 };
1639
1640 void
1641 tulip_21140_cogent_em100_media_probe(tulip_softc_t * const sc)
1642 {
1643 tulip_media_info_t *mip = sc->tulip_mediainfo;
1644 u_int32_t cmdmode = TULIP_CSR_READ(sc, csr_command);
1645
1646 sc->tulip_gpinit = TULIP_GP_EM100_PINS;
1647 sc->tulip_gpdata = TULIP_GP_EM100_INIT;
1648 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EM100_PINS);
1649 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_EM100_INIT);
1650
1651 cmdmode = TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION|TULIP_CMD_MUSTBEONE;
1652 cmdmode &= ~(TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_SCRAMBLER);
1653 if (sc->tulip_rombuf[32] == TULIP_COGENT_EM100FX_ID) {
1654 TULIP_CSR_WRITE(sc, csr_command, cmdmode);
1655 sc->tulip_media = TULIP_MEDIA_100BASEFX;
1656
1657 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASEFX,
1658 TULIP_GP_EM100_INIT,
1659 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION);
1660 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASEFX_FD,
1661 TULIP_GP_EM100_INIT,
1662 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1663 |TULIP_CMD_FULLDUPLEX);
1664 } else {
1665 TULIP_CSR_WRITE(sc, csr_command, cmdmode|TULIP_CMD_SCRAMBLER);
1666 sc->tulip_media = TULIP_MEDIA_100BASETX;
1667 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
1668 TULIP_GP_EM100_INIT,
1669 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1670 |TULIP_CMD_SCRAMBLER);
1671 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
1672 TULIP_GP_EM100_INIT,
1673 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1674 |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
1675 }
1676 }
1677
1678 static const tulip_boardsw_t tulip_21140_cogent_em100_boardsw = {
1679 TULIP_21140_COGENT_EM100,
1680 tulip_21140_cogent_em100_media_probe,
1681 tulip_media_select,
1682 tulip_null_media_poll,
1683 tulip_2114x_media_preset
1684 };
1685
1686 void
1687 tulip_21140_znyx_zx34x_media_probe(tulip_softc_t * const sc)
1688 {
1689 tulip_media_info_t *mip = sc->tulip_mediainfo;
1690 int cnt10 = 0, cnt100 = 0, idx;
1691
1692 sc->tulip_gpinit = TULIP_GP_ZX34X_PINS;
1693 sc->tulip_gpdata = TULIP_GP_ZX34X_INIT;
1694 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_ZX34X_PINS);
1695 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_ZX34X_INIT);
1696 TULIP_CSR_WRITE(sc, csr_command,
1697 TULIP_CSR_READ(sc, csr_command) | TULIP_CMD_PORTSELECT |
1698 TULIP_CMD_PCSFUNCTION | TULIP_CMD_SCRAMBLER | TULIP_CMD_MUSTBEONE);
1699 TULIP_CSR_WRITE(sc, csr_command,
1700 TULIP_CSR_READ(sc, csr_command) & ~TULIP_CMD_TXTHRSHLDCTL);
1701
1702 DELAY(200000);
1703 for (idx = 1000; idx > 0; idx--) {
1704 u_int32_t csr = TULIP_CSR_READ(sc, csr_gp);
1705 if ((csr & (TULIP_GP_ZX34X_LNKFAIL|TULIP_GP_ZX34X_SYMDET|TULIP_GP_ZX34X_SIGDET)) == (TULIP_GP_ZX34X_LNKFAIL|TULIP_GP_ZX34X_SYMDET|TULIP_GP_ZX34X_SIGDET)) {
1706 if (++cnt100 > 100)
1707 break;
1708 } else if ((csr & TULIP_GP_ZX34X_LNKFAIL) == 0) {
1709 if (++cnt10 > 100)
1710 break;
1711 } else {
1712 cnt10 = 0;
1713 cnt100 = 0;
1714 }
1715 DELAY(1000);
1716 }
1717 sc->tulip_media = cnt100 > 100 ? TULIP_MEDIA_100BASETX : TULIP_MEDIA_10BASET;
1718 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET,
1719 TULIP_GP_ZX34X_INIT,
1720 TULIP_CMD_TXTHRSHLDCTL);
1721 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_10BASET_FD,
1722 TULIP_GP_ZX34X_INIT,
1723 TULIP_CMD_TXTHRSHLDCTL|TULIP_CMD_FULLDUPLEX);
1724 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX,
1725 TULIP_GP_ZX34X_INIT,
1726 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1727 |TULIP_CMD_SCRAMBLER);
1728 tulip_21140_mediainit(sc, mip++, TULIP_MEDIA_100BASETX_FD,
1729 TULIP_GP_ZX34X_INIT,
1730 TULIP_CMD_PORTSELECT|TULIP_CMD_PCSFUNCTION
1731 |TULIP_CMD_SCRAMBLER|TULIP_CMD_FULLDUPLEX);
1732 }
1733
1734 static const tulip_boardsw_t tulip_21140_znyx_zx34x_boardsw = {
1735 TULIP_21140_ZNYX_ZX34X,
1736 tulip_21140_znyx_zx34x_media_probe,
1737 tulip_media_select,
1738 tulip_null_media_poll,
1739 tulip_2114x_media_preset,
1740 };
1741
1742 void
1743 tulip_2114x_media_probe(tulip_softc_t * const sc)
1744 {
1745 sc->tulip_cmdmode |= TULIP_CMD_MUSTBEONE
1746 |TULIP_CMD_BACKOFFCTR|TULIP_CMD_THRSHLD72;
1747 }
1748
1749 static const tulip_boardsw_t tulip_2114x_isv_boardsw = {
1750 TULIP_21140_ISV,
1751 tulip_2114x_media_probe,
1752 tulip_media_select,
1753 tulip_media_poll,
1754 tulip_2114x_media_preset,
1755 };
1756
1757
1758
1759
1760
1761
1762
1763
1764 void
1765 tulip_delay_300ns(tulip_softc_t * const sc)
1766 {
1767 int idx;
1768 for (idx = (300 / 33) + 1; idx > 0; idx--)
1769 (void) TULIP_CSR_READ(sc, csr_busmode);
1770 }
1771
1772 void
1773 tulip_srom_idle(tulip_softc_t * const sc)
1774 {
1775 unsigned bit, csr;
1776
1777 csr = SROMSEL ; EMIT;
1778 csr = SROMSEL | SROMRD; EMIT;
1779 csr ^= SROMCS; EMIT;
1780 csr ^= SROMCLKON; EMIT;
1781
1782
1783
1784
1785 for (bit = 3 + SROM_BITWIDTH + 16; bit > 0; bit--) {
1786 csr ^= SROMCLKOFF; EMIT;
1787 csr ^= SROMCLKON; EMIT;
1788 }
1789 csr ^= SROMCLKOFF; EMIT;
1790 csr ^= SROMCS; EMIT;
1791 csr = 0; EMIT;
1792 }
1793
1794 void
1795 tulip_srom_read(tulip_softc_t * const sc)
1796 {
1797 unsigned idx;
1798 const unsigned bitwidth = SROM_BITWIDTH;
1799 const unsigned cmdmask = (SROMCMD_RD << bitwidth);
1800 const unsigned msb = 1 << (bitwidth + 3 - 1);
1801 unsigned lastidx = (1 << bitwidth) - 1;
1802
1803 tulip_srom_idle(sc);
1804
1805 for (idx = 0; idx <= lastidx; idx++) {
1806 unsigned lastbit, data, bits, bit, csr;
1807 csr = SROMSEL ; EMIT;
1808 csr = SROMSEL | SROMRD; EMIT;
1809 csr ^= SROMCSON; EMIT;
1810 csr ^= SROMCLKON; EMIT;
1811
1812 lastbit = 0;
1813 for (bits = idx|cmdmask, bit = bitwidth + 3; bit > 0; bit--, bits <<= 1) {
1814 const unsigned thisbit = bits & msb;
1815 csr ^= SROMCLKOFF; EMIT;
1816 if (thisbit != lastbit) {
1817 csr ^= SROMDOUT; EMIT;
1818 } else {
1819 EMIT;
1820 }
1821 csr ^= SROMCLKON; EMIT;
1822 lastbit = thisbit;
1823 }
1824 csr ^= SROMCLKOFF; EMIT;
1825
1826 for (data = 0, bits = 0; bits < 16; bits++) {
1827 data <<= 1;
1828 csr ^= SROMCLKON; EMIT;
1829 data |= TULIP_CSR_READ(sc, csr_srom_mii) & SROMDIN ? 1 : 0;
1830 csr ^= SROMCLKOFF; EMIT;
1831 }
1832 sc->tulip_rombuf[idx*2] = data & 0xFF;
1833 sc->tulip_rombuf[idx*2+1] = data >> 8;
1834 csr = SROMSEL | SROMRD; EMIT;
1835 csr = 0; EMIT;
1836 }
1837 tulip_srom_idle(sc);
1838 }
1839
1840 void
1841 tulip_mii_writebits(tulip_softc_t * const sc, unsigned data, unsigned bits)
1842 {
1843 unsigned msb = 1 << (bits - 1);
1844 unsigned csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
1845 unsigned lastbit = (csr & MII_DOUT) ? msb : 0;
1846
1847 csr |= MII_WR; MII_EMIT;
1848
1849 for (; bits > 0; bits--, data <<= 1) {
1850 const unsigned thisbit = data & msb;
1851 if (thisbit != lastbit)
1852 csr ^= MII_DOUT; MII_EMIT;
1853 csr ^= MII_CLKON; MII_EMIT;
1854 lastbit = thisbit;
1855 csr ^= MII_CLKOFF; MII_EMIT;
1856 }
1857 }
1858
1859 void
1860 tulip_mii_turnaround(tulip_softc_t * const sc, unsigned cmd)
1861 {
1862 unsigned csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
1863
1864 if (cmd == MII_WRCMD) {
1865 csr |= MII_DOUT; MII_EMIT;
1866 csr ^= MII_CLKON; MII_EMIT;
1867 csr ^= MII_CLKOFF; MII_EMIT;
1868 csr ^= MII_DOUT; MII_EMIT;
1869 } else
1870 csr |= MII_RD; MII_EMIT;
1871 csr ^= MII_CLKON; MII_EMIT;
1872 csr ^= MII_CLKOFF; MII_EMIT;
1873 }
1874
1875 unsigned
1876 tulip_mii_readbits(tulip_softc_t * const sc)
1877 {
1878 unsigned data;
1879 unsigned csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
1880 int idx;
1881
1882 for (idx = 0, data = 0; idx < 16; idx++) {
1883 data <<= 1;
1884 csr ^= MII_CLKON; MII_EMIT;
1885 if (TULIP_CSR_READ(sc, csr_srom_mii) & MII_DIN)
1886 data |= 1;
1887 csr ^= MII_CLKOFF; MII_EMIT;
1888 }
1889 csr ^= MII_RD; MII_EMIT;
1890
1891 return (data);
1892 }
1893
1894 unsigned
1895 tulip_mii_readreg(tulip_softc_t * const sc, unsigned devaddr, unsigned regno)
1896 {
1897 unsigned csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
1898 unsigned data;
1899
1900 csr &= ~(MII_RD|MII_CLK); MII_EMIT;
1901 tulip_mii_writebits(sc, MII_PREAMBLE, 32);
1902 tulip_mii_writebits(sc, MII_RDCMD, 8);
1903 tulip_mii_writebits(sc, devaddr, 5);
1904 tulip_mii_writebits(sc, regno, 5);
1905 tulip_mii_turnaround(sc, MII_RDCMD);
1906
1907 data = tulip_mii_readbits(sc);
1908 #if defined(TULIP_DEBUG)
1909 sc->tulip_dbg.dbg_phyregs[regno][0] = data;
1910 sc->tulip_dbg.dbg_phyregs[regno][1]++;
1911 #endif
1912 return (data);
1913 }
1914
1915 void
1916 tulip_mii_writereg(tulip_softc_t * const sc, unsigned devaddr,
1917 unsigned regno, unsigned data)
1918 {
1919 unsigned csr;
1920
1921 csr = TULIP_CSR_READ(sc, csr_srom_mii) & (MII_RD|MII_DOUT|MII_CLK);
1922 csr &= ~(MII_RD|MII_CLK); MII_EMIT;
1923 tulip_mii_writebits(sc, MII_PREAMBLE, 32);
1924 tulip_mii_writebits(sc, MII_WRCMD, 8);
1925 tulip_mii_writebits(sc, devaddr, 5);
1926 tulip_mii_writebits(sc, regno, 5);
1927 tulip_mii_turnaround(sc, MII_WRCMD);
1928 tulip_mii_writebits(sc, data, 16);
1929 #if defined(TULIP_DEBUG)
1930 sc->tulip_dbg.dbg_phyregs[regno][2] = data;
1931 sc->tulip_dbg.dbg_phyregs[regno][3]++;
1932 #endif
1933 }
1934
1935 void
1936 tulip_identify_dec_nic(tulip_softc_t * const sc)
1937 {
1938 strlcpy(sc->tulip_boardid, "DEC ", sizeof(sc->tulip_boardid));
1939 #define D0 4
1940 if (sc->tulip_chipid <= TULIP_DE425)
1941 return;
1942 if (bcmp(sc->tulip_rombuf + 29, "DE500", 5) == 0
1943 || bcmp(sc->tulip_rombuf + 29, "DE450", 5) == 0) {
1944 bcopy(sc->tulip_rombuf + 29, &sc->tulip_boardid[D0], 8);
1945 sc->tulip_boardid[D0+8] = ' ';
1946 }
1947 #undef D0
1948 }
1949
1950 void
1951 tulip_identify_znyx_nic(tulip_softc_t * const sc)
1952 {
1953 unsigned id = 0;
1954 strlcpy(sc->tulip_boardid, "ZNYX ZX3XX ", sizeof(sc->tulip_boardid));
1955 if (sc->tulip_chipid == TULIP_21140 || sc->tulip_chipid == TULIP_21140A) {
1956 unsigned znyx_ptr;
1957 sc->tulip_boardid[8] = '4';
1958 znyx_ptr = sc->tulip_rombuf[124] + 256 * sc->tulip_rombuf[125];
1959 if (znyx_ptr < 26 || znyx_ptr > 116) {
1960 sc->tulip_boardsw = &tulip_21140_znyx_zx34x_boardsw;
1961 return;
1962 }
1963
1964
1965 if (sc->tulip_rombuf[znyx_ptr] == 0x4A
1966 && sc->tulip_rombuf[znyx_ptr + 1] == 0x52
1967 && sc->tulip_rombuf[znyx_ptr + 2] == 0x01) {
1968 id = sc->tulip_rombuf[znyx_ptr + 5] + 256 * sc->tulip_rombuf[znyx_ptr + 4];
1969 if ((id >> 8) == (TULIP_ZNYX_ID_ZX342 >> 8)) {
1970 sc->tulip_boardid[9] = '2';
1971 if (id == TULIP_ZNYX_ID_ZX342B) {
1972 sc->tulip_boardid[10] = 'B';
1973 sc->tulip_boardid[11] = ' ';
1974 }
1975 sc->tulip_boardsw = &tulip_21140_znyx_zx34x_boardsw;
1976 } else if (id == TULIP_ZNYX_ID_ZX344) {
1977 sc->tulip_boardid[10] = '4';
1978 sc->tulip_boardsw = &tulip_21140_znyx_zx34x_boardsw;
1979 } else if (id == TULIP_ZNYX_ID_ZX345) {
1980 sc->tulip_boardid[9] = (sc->tulip_rombuf[19] > 1) ? '8' : '5';
1981 } else if (id == TULIP_ZNYX_ID_ZX346) {
1982 sc->tulip_boardid[9] = '6';
1983 } else if (id == TULIP_ZNYX_ID_ZX351) {
1984 sc->tulip_boardid[8] = '5';
1985 sc->tulip_boardid[9] = '1';
1986 }
1987 }
1988 if (id == 0) {
1989
1990
1991
1992 sc->tulip_boardsw = &tulip_21140_znyx_zx34x_boardsw;
1993 }
1994 return;
1995 }
1996 sc->tulip_boardid[8] = '1';
1997 if (sc->tulip_chipid == TULIP_21041) {
1998 sc->tulip_boardid[10] = '1';
1999 return;
2000 }
2001 if (sc->tulip_rombuf[32] == 0x4A && sc->tulip_rombuf[33] == 0x52) {
2002 id = sc->tulip_rombuf[37] + 256 * sc->tulip_rombuf[36];
2003 if (id == TULIP_ZNYX_ID_ZX312T) {
2004 sc->tulip_boardid[9] = '2';
2005 sc->tulip_boardid[10] = 'T';
2006 sc->tulip_boardid[11] = ' ';
2007 sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
2008 } else if (id == TULIP_ZNYX_ID_ZX314_INTA) {
2009 sc->tulip_boardid[9] = '4';
2010 sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
2011 sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
2012 } else if (id == TULIP_ZNYX_ID_ZX314) {
2013 sc->tulip_boardid[9] = '4';
2014 sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
2015 sc->tulip_features |= TULIP_HAVE_BASEROM;
2016 } else if (id == TULIP_ZNYX_ID_ZX315_INTA) {
2017 sc->tulip_boardid[9] = '5';
2018 sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
2019 } else if (id == TULIP_ZNYX_ID_ZX315) {
2020 sc->tulip_boardid[9] = '5';
2021 sc->tulip_features |= TULIP_HAVE_BASEROM;
2022 } else
2023 id = 0;
2024 }
2025 if (id == 0) {
2026 if ((sc->tulip_enaddr[3] & ~3) == 0xF0 && (sc->tulip_enaddr[5] & 3) == 0) {
2027 sc->tulip_boardid[9] = '4';
2028 sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
2029 sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
2030 } else if ((sc->tulip_enaddr[3] & ~3) == 0xF4 && (sc->tulip_enaddr[5] & 1) == 0) {
2031 sc->tulip_boardid[9] = '5';
2032 sc->tulip_boardsw = &tulip_21040_boardsw;
2033 sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
2034 } else if ((sc->tulip_enaddr[3] & ~3) == 0xEC) {
2035 sc->tulip_boardid[9] = '2';
2036 sc->tulip_boardsw = &tulip_21040_boardsw;
2037 }
2038 }
2039 }
2040
2041 void
2042 tulip_identify_smc_nic(tulip_softc_t * const sc)
2043 {
2044 u_int32_t id1, id2, ei;
2045 int auibnc = 0, utp = 0;
2046 char *cp;
2047
2048 strlcpy(sc->tulip_boardid, "SMC ", sizeof(sc->tulip_boardid));
2049 if (sc->tulip_chipid == TULIP_21041)
2050 return;
2051 if (sc->tulip_chipid != TULIP_21040) {
2052 if (sc->tulip_boardsw != &tulip_2114x_isv_boardsw) {
2053 strlcat(sc->tulip_boardid, "9332DST ", sizeof(sc->tulip_boardid));
2054 sc->tulip_boardsw = &tulip_21140_smc9332_boardsw;
2055 } else if (sc->tulip_features & (TULIP_HAVE_BASEROM|TULIP_HAVE_SLAVEDROM))
2056 strlcat(sc->tulip_boardid, "9334BDT ", sizeof(sc->tulip_boardid));
2057 else
2058 strlcat(sc->tulip_boardid, "9332BDT ", sizeof(sc->tulip_boardid));
2059 return;
2060 }
2061 id1 = sc->tulip_rombuf[0x60] | (sc->tulip_rombuf[0x61] << 8);
2062 id2 = sc->tulip_rombuf[0x62] | (sc->tulip_rombuf[0x63] << 8);
2063 ei = sc->tulip_rombuf[0x66] | (sc->tulip_rombuf[0x67] << 8);
2064
2065 strlcat(sc->tulip_boardid, "8432", sizeof(sc->tulip_boardid));
2066 cp = &sc->tulip_boardid[8];
2067 if ((id1 & 1) == 0)
2068 *cp++ = 'B', auibnc = 1;
2069 if ((id1 & 0xFF) > 0x32)
2070 *cp++ = 'T', utp = 1;
2071 if ((id1 & 0x4000) == 0)
2072 *cp++ = 'A', auibnc = 1;
2073 if (id2 == 0x15) {
2074 sc->tulip_boardid[7] = '4';
2075 *cp++ = '-';
2076 *cp++ = 'C';
2077 *cp++ = 'H';
2078 *cp++ = (ei ? '2' : '1');
2079 }
2080 *cp++ = ' ';
2081 *cp = '\0';
2082 if (utp && !auibnc)
2083 sc->tulip_boardsw = &tulip_21040_10baset_only_boardsw;
2084 else if (!utp && auibnc)
2085 sc->tulip_boardsw = &tulip_21040_auibnc_only_boardsw;
2086 }
2087
2088 void
2089 tulip_identify_cogent_nic(tulip_softc_t * const sc)
2090 {
2091 strlcpy(sc->tulip_boardid, "Cogent ", sizeof(sc->tulip_boardid));
2092 if (sc->tulip_chipid == TULIP_21140 || sc->tulip_chipid == TULIP_21140A) {
2093 if (sc->tulip_rombuf[32] == TULIP_COGENT_EM100TX_ID) {
2094 strlcat(sc->tulip_boardid, "EM100TX ", sizeof(sc->tulip_boardid));
2095 sc->tulip_boardsw = &tulip_21140_cogent_em100_boardsw;
2096 #if defined(TULIP_COGENT_EM110TX_ID)
2097 } else if (sc->tulip_rombuf[32] == TULIP_COGENT_EM110TX_ID) {
2098 strlcat(sc->tulip_boardid, "EM110TX ", sizeof(sc->tulip_boardid));
2099 sc->tulip_boardsw = &tulip_21140_cogent_em100_boardsw;
2100 #endif
2101 } else if (sc->tulip_rombuf[32] == TULIP_COGENT_EM100FX_ID) {
2102 strlcat(sc->tulip_boardid, "EM100FX ", sizeof(sc->tulip_boardid));
2103 sc->tulip_boardsw = &tulip_21140_cogent_em100_boardsw;
2104 }
2105
2106
2107
2108
2109 if (*(u_int32_t *) sc->tulip_rombuf == 0x24001109U
2110 && (sc->tulip_features & TULIP_HAVE_BASEROM)) {
2111
2112
2113
2114
2115 strlcat(sc->tulip_boardid, "EM440TX ", sizeof(sc->tulip_boardid));
2116 sc->tulip_features |= TULIP_HAVE_SHAREDINTR;
2117 }
2118 } else if (sc->tulip_chipid == TULIP_21040)
2119 sc->tulip_features |= TULIP_HAVE_SHAREDINTR|TULIP_HAVE_BASEROM;
2120 }
2121
2122 void
2123 tulip_identify_accton_nic(tulip_softc_t * const sc)
2124 {
2125 strlcpy(sc->tulip_boardid, "ACCTON ", sizeof(sc->tulip_boardid));
2126 switch (sc->tulip_chipid) {
2127 case TULIP_21140A:
2128 strlcat(sc->tulip_boardid, "EN1207 ", sizeof(sc->tulip_boardid));
2129 if (sc->tulip_boardsw != &tulip_2114x_isv_boardsw)
2130 sc->tulip_boardsw = &tulip_21140_accton_boardsw;
2131 break;
2132 case TULIP_21140:
2133 strlcat(sc->tulip_boardid, "EN1207TX ", sizeof(sc->tulip_boardid));
2134 if (sc->tulip_boardsw != &tulip_2114x_isv_boardsw)
2135 sc->tulip_boardsw = &tulip_21140_eb_boardsw;
2136 break;
2137 case TULIP_21040:
2138 strlcat(sc->tulip_boardid, "EN1203 ", sizeof(sc->tulip_boardid));
2139 sc->tulip_boardsw = &tulip_21040_boardsw;
2140 break;
2141 case TULIP_21041:
2142 strlcat(sc->tulip_boardid, "EN1203 ", sizeof(sc->tulip_boardid));
2143 sc->tulip_boardsw = &tulip_21041_boardsw;
2144 break;
2145 default:
2146 sc->tulip_boardsw = &tulip_2114x_isv_boardsw;
2147 break;
2148 }
2149 }
2150
2151 void
2152 tulip_identify_asante_nic(tulip_softc_t * const sc)
2153 {
2154 strlcpy(sc->tulip_boardid, "Asante ", sizeof(sc->tulip_boardid));
2155 if ((sc->tulip_chipid == TULIP_21140 || sc->tulip_chipid == TULIP_21140A)
2156 && sc->tulip_boardsw != &tulip_2114x_isv_boardsw) {
2157 tulip_media_info_t *mi = sc->tulip_mediainfo;
2158 int idx;
2159
2160
2161
2162
2163
2164
2165 sc->tulip_gpinit = TULIP_GP_ASANTE_PINS;
2166 sc->tulip_gpdata = 0;
2167
2168 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_ASANTE_PINS|TULIP_GP_PINSET);
2169 TULIP_CSR_WRITE(sc, csr_gp, TULIP_GP_ASANTE_PHYRESET);
2170 DELAY(100);
2171 TULIP_CSR_WRITE(sc, csr_gp, 0);
2172
2173 mi->mi_type = TULIP_MEDIAINFO_MII;
2174 mi->mi_gpr_length = 0;
2175 mi->mi_gpr_offset = 0;
2176 mi->mi_reset_length = 0;
2177 mi->mi_reset_offset = 0;
2178
2179 mi->mi_phyaddr = TULIP_MII_NOPHY;
2180 for (idx = 20; idx > 0 && mi->mi_phyaddr == TULIP_MII_NOPHY; idx--) {
2181 DELAY(10000);
2182 mi->mi_phyaddr = tulip_mii_get_phyaddr(sc, 0);
2183 }
2184 if (mi->mi_phyaddr == TULIP_MII_NOPHY) {
2185 #ifdef TULIP_DEBUG
2186 printf(TULIP_PRINTF_FMT ": can't find phy 0\n", TULIP_PRINTF_ARGS);
2187 #endif
2188 return;
2189 }
2190
2191 sc->tulip_features |= TULIP_HAVE_MII;
2192 mi->mi_capabilities = PHYSTS_10BASET|PHYSTS_10BASET_FD|PHYSTS_100BASETX|PHYSTS_100BASETX_FD;
2193 mi->mi_advertisement = PHYSTS_10BASET|PHYSTS_10BASET_FD|PHYSTS_100BASETX|PHYSTS_100BASETX_FD;
2194 mi->mi_full_duplex = PHYSTS_10BASET_FD|PHYSTS_100BASETX_FD;
2195 mi->mi_tx_threshold = PHYSTS_10BASET|PHYSTS_10BASET_FD;
2196 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX_FD);
2197 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX);
2198 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASET4);
2199 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET_FD);
2200 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET);
2201 mi->mi_phyid = (tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDLOW) << 16) |
2202 tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDHIGH);
2203
2204 sc->tulip_boardsw = &tulip_2114x_isv_boardsw;
2205 }
2206 }
2207
2208 void
2209 tulip_identify_compex_nic(tulip_softc_t * const sc)
2210 {
2211 strlcpy(sc->tulip_boardid, "COMPEX ", sizeof(sc->tulip_boardid));
2212 if (sc->tulip_chipid == TULIP_21140A) {
2213 int root_unit;
2214 tulip_softc_t *root_sc = NULL;
2215
2216 strlcat(sc->tulip_boardid, "400TX/PCI ", sizeof(sc->tulip_boardid));
2217
2218
2219
2220
2221 sc->tulip_features |= TULIP_HAVE_SHAREDINTR;
2222 for (root_unit = sc->tulip_unit - 1; root_unit >= 0; root_unit--) {
2223 root_sc = TULIP_UNIT_TO_SOFTC(root_unit);
2224 if (root_sc == NULL
2225 || !(root_sc->tulip_features & TULIP_HAVE_SLAVEDINTR))
2226 break;
2227 root_sc = NULL;
2228 }
2229 if (root_sc != NULL
2230 && root_sc->tulip_chipid == sc->tulip_chipid
2231 && root_sc->tulip_pci_busno == sc->tulip_pci_busno) {
2232 sc->tulip_features |= TULIP_HAVE_SLAVEDINTR;
2233 sc->tulip_slaves = root_sc->tulip_slaves;
2234 root_sc->tulip_slaves = sc;
2235 } else if(sc->tulip_features & TULIP_HAVE_SLAVEDINTR)
2236 printf("\nCannot find master device for de%d interrupts", sc->tulip_unit);
2237 } else
2238 strlcat(sc->tulip_boardid, "unknown ", sizeof(sc->tulip_boardid));
2239
2240
2241 }
2242
2243 int
2244 tulip_srom_decode(tulip_softc_t * const sc)
2245 {
2246 unsigned idx1, idx2, idx3;
2247
2248 const tulip_srom_header_t *shp = (tulip_srom_header_t *) &sc->tulip_rombuf[0];
2249 const tulip_srom_adapter_info_t *saip = (tulip_srom_adapter_info_t *) (shp + 1);
2250 tulip_srom_media_t srom_media;
2251 tulip_media_info_t *mi = sc->tulip_mediainfo;
2252 const u_int8_t *dp;
2253 u_int32_t leaf_offset, blocks, data;
2254
2255 for (idx1 = 0; idx1 < shp->sh_adapter_count; idx1++, saip++) {
2256 if (shp->sh_adapter_count == 1)
2257 break;
2258 if (saip->sai_device == sc->tulip_pci_devno)
2259 break;
2260 }
2261
2262
2263
2264 if (idx1 == shp->sh_adapter_count)
2265 return (0);
2266
2267
2268
2269
2270 bcopy((caddr_t) shp->sh_ieee802_address, (caddr_t) sc->tulip_enaddr,
2271 ETHER_ADDR_LEN);
2272
2273
2274
2275
2276
2277 sc->tulip_enaddr[5] += idx1;
2278
2279 leaf_offset = saip->sai_leaf_offset_lowbyte
2280 + saip->sai_leaf_offset_highbyte * 256;
2281 dp = sc->tulip_rombuf + leaf_offset;
2282
2283 sc->tulip_conntype = (tulip_srom_connection_t) (dp[0] + dp[1] * 256); dp += 2;
2284
2285 for (idx2 = 0;; idx2++) {
2286 if (tulip_srom_conninfo[idx2].sc_type == sc->tulip_conntype
2287 || tulip_srom_conninfo[idx2].sc_type == TULIP_SROM_CONNTYPE_NOT_USED)
2288 break;
2289 }
2290 sc->tulip_connidx = idx2;
2291
2292 if (sc->tulip_chipid == TULIP_21041) {
2293 blocks = *dp++;
2294 for (idx2 = 0; idx2 < blocks; idx2++) {
2295 tulip_media_t media;
2296 data = *dp++;
2297 srom_media = (tulip_srom_media_t) (data & 0x3F);
2298 for (idx3 = 0; tulip_srom_mediums[idx3].sm_type != TULIP_MEDIA_UNKNOWN; idx3++) {
2299 if (tulip_srom_mediums[idx3].sm_srom_type == srom_media)
2300 break;
2301 }
2302 media = tulip_srom_mediums[idx3].sm_type;
2303 if (media != TULIP_MEDIA_UNKNOWN) {
2304 if (data & TULIP_SROM_21041_EXTENDED) {
2305 mi->mi_type = TULIP_MEDIAINFO_SIA;
2306 sc->tulip_mediums[media] = mi;
2307 mi->mi_sia_connectivity = dp[0] + dp[1] * 256;
2308 mi->mi_sia_tx_rx = dp[2] + dp[3] * 256;
2309 mi->mi_sia_general = dp[4] + dp[5] * 256;
2310 mi++;
2311 } else {
2312 switch (media) {
2313 case TULIP_MEDIA_BNC: {
2314 TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21041, BNC);
2315 mi++;
2316 break;
2317 }
2318 case TULIP_MEDIA_AUI: {
2319 TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21041, AUI);
2320 mi++;
2321 break;
2322 }
2323 case TULIP_MEDIA_10BASET: {
2324 TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21041, 10BASET);
2325 mi++;
2326 break;
2327 }
2328 case TULIP_MEDIA_10BASET_FD: {
2329 TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21041, 10BASET_FD);
2330 mi++;
2331 break;
2332 }
2333 default: {
2334 break;
2335 }
2336 }
2337 }
2338 }
2339 if (data & TULIP_SROM_21041_EXTENDED)
2340 dp += 6;
2341 }
2342 } else {
2343 unsigned length, type;
2344 tulip_media_t gp_media = TULIP_MEDIA_UNKNOWN;
2345 if (sc->tulip_features & TULIP_HAVE_GPR)
2346 sc->tulip_gpinit = *dp++;
2347 blocks = *dp++;
2348 for (idx2 = 0; idx2 < blocks; idx2++) {
2349 const u_int8_t *ep;
2350 if ((*dp & 0x80) == 0) {
2351 length = 4;
2352 type = 0;
2353 } else {
2354 length = (*dp++ & 0x7f) - 1;
2355 type = *dp++ & 0x3f;
2356 }
2357 ep = dp + length;
2358 switch (type & 0x3f) {
2359 case 0: {
2360 tulip_media_t media;
2361 srom_media = (tulip_srom_media_t)(dp[0] & 0x3f);
2362 for (idx3 = 0; tulip_srom_mediums[idx3].sm_type != TULIP_MEDIA_UNKNOWN; idx3++) {
2363 if (tulip_srom_mediums[idx3].sm_srom_type == srom_media)
2364 break;
2365 }
2366 media = tulip_srom_mediums[idx3].sm_type;
2367 if (media == TULIP_MEDIA_UNKNOWN)
2368 break;
2369 mi->mi_type = TULIP_MEDIAINFO_GPR;
2370 sc->tulip_mediums[media] = mi;
2371 mi->mi_gpdata = dp[1];
2372 if (media > gp_media && !TULIP_IS_MEDIA_FD(media)) {
2373 sc->tulip_gpdata = mi->mi_gpdata;
2374 gp_media = media;
2375 }
2376 data = dp[2] + dp[3] * 256;
2377 mi->mi_cmdmode = TULIP_SROM_2114X_CMDBITS(data);
2378 if (data & TULIP_SROM_2114X_NOINDICATOR)
2379 mi->mi_actmask = 0;
2380 else {
2381 mi->mi_actmask = TULIP_SROM_2114X_BITPOS(data);
2382 mi->mi_actdata = (data & TULIP_SROM_2114X_POLARITY) ? 0 : mi->mi_actmask;
2383 }
2384 mi++;
2385 break;
2386 }
2387 case 1: {
2388 const unsigned phyno = *dp++;
2389 mi->mi_type = TULIP_MEDIAINFO_MII;
2390 mi->mi_gpr_length = *dp++;
2391 mi->mi_gpr_offset = dp - sc->tulip_rombuf;
2392 dp += mi->mi_gpr_length;
2393 mi->mi_reset_length = *dp++;
2394 mi->mi_reset_offset = dp - sc->tulip_rombuf;
2395 dp += mi->mi_reset_length;
2396
2397
2398
2399
2400
2401 TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_gpinit|TULIP_GP_PINSET);
2402 for (idx3 = 0; idx3 < mi->mi_reset_length; idx3++) {
2403 DELAY(10);
2404 TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_rombuf[mi->mi_reset_offset + idx3]);
2405 }
2406 sc->tulip_phyaddr = mi->mi_phyaddr;
2407 for (idx3 = 0; idx3 < mi->mi_gpr_length; idx3++) {
2408 DELAY(10);
2409 TULIP_CSR_WRITE(sc, csr_gp, sc->tulip_rombuf[mi->mi_gpr_offset + idx3]);
2410 }
2411
2412
2413
2414
2415 if (mi->mi_reset_length == 0 && mi->mi_gpr_length == 0)
2416 TULIP_CSR_WRITE(sc, csr_gp, 0);
2417
2418 mi->mi_phyaddr = TULIP_MII_NOPHY;
2419 for (idx3 = 20; idx3 > 0 && mi->mi_phyaddr == TULIP_MII_NOPHY; idx3--) {
2420 DELAY(10000);
2421 mi->mi_phyaddr = tulip_mii_get_phyaddr(sc, phyno);
2422 }
2423 if (mi->mi_phyaddr == TULIP_MII_NOPHY) {
2424 #if defined(TULIP_DEBUG)
2425 printf(TULIP_PRINTF_FMT ": can't find phy %d\n",
2426 TULIP_PRINTF_ARGS, phyno);
2427 #endif
2428 break;
2429 }
2430 sc->tulip_features |= TULIP_HAVE_MII;
2431 mi->mi_capabilities = dp[0] + dp[1] * 256; dp += 2;
2432 mi->mi_advertisement = dp[0] + dp[1] * 256; dp += 2;
2433 mi->mi_full_duplex = dp[0] + dp[1] * 256; dp += 2;
2434 mi->mi_tx_threshold = dp[0] + dp[1] * 256; dp += 2;
2435 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX_FD);
2436 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX);
2437 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASET4);
2438 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET_FD);
2439 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET);
2440 mi->mi_phyid = (tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDLOW) << 16) |
2441 tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDHIGH);
2442 mi++;
2443 break;
2444 }
2445 case 2: {
2446 tulip_media_t media;
2447 srom_media = (tulip_srom_media_t)(dp[0] & 0x3f);
2448 for (idx3 = 0; tulip_srom_mediums[idx3].sm_type != TULIP_MEDIA_UNKNOWN; idx3++) {
2449 if (tulip_srom_mediums[idx3].sm_srom_type == srom_media)
2450 break;
2451 }
2452 media = tulip_srom_mediums[idx3].sm_type;
2453 if (media == TULIP_MEDIA_UNKNOWN)
2454 break;
2455 mi->mi_type = TULIP_MEDIAINFO_SIA;
2456 sc->tulip_mediums[media] = mi;
2457 if (dp[0] & 0x40) {
2458 mi->mi_sia_connectivity = dp[1] + dp[2] * 256;
2459 mi->mi_sia_tx_rx = dp[3] + dp[4] * 256;
2460 mi->mi_sia_general = dp[5] + dp[6] * 256;
2461 dp += 6;
2462 } else {
2463 switch (media) {
2464 case TULIP_MEDIA_BNC: {
2465 TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21142, BNC);
2466 break;
2467 }
2468 case TULIP_MEDIA_AUI: {
2469 TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21142, AUI);
2470 break;
2471 }
2472 case TULIP_MEDIA_10BASET: {
2473 TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21142, 10BASET);
2474 sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
2475 break;
2476 }
2477 case TULIP_MEDIA_10BASET_FD: {
2478 TULIP_MEDIAINFO_SIA_INIT(sc, mi, 21142, 10BASET_FD);
2479 sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
2480 break;
2481 }
2482 default: {
2483 goto bad_media;
2484 }
2485 }
2486 }
2487 mi->mi_sia_gp_control = (dp[1] + dp[2] * 256) << 16;
2488 mi->mi_sia_gp_data = (dp[3] + dp[4] * 256) << 16;
2489 mi++;
2490 bad_media:
2491 break;
2492 }
2493 case 3: {
2494 const unsigned phyno = *dp++;
2495 const u_int8_t *dp0;
2496 mi->mi_type = TULIP_MEDIAINFO_MII;
2497 mi->mi_gpr_length = *dp++;
2498 mi->mi_gpr_offset = dp - sc->tulip_rombuf;
2499 dp += 2 * mi->mi_gpr_length;
2500 mi->mi_reset_length = *dp++;
2501 mi->mi_reset_offset = dp - sc->tulip_rombuf;
2502 dp += 2 * mi->mi_reset_length;
2503
2504 dp0 = &sc->tulip_rombuf[mi->mi_reset_offset];
2505 for (idx3 = 0; idx3 < mi->mi_reset_length; idx3++, dp0 += 2) {
2506 DELAY(10);
2507 TULIP_CSR_WRITE(sc, csr_sia_general, (dp0[0] + 256 * dp0[1]) << 16);
2508 }
2509 sc->tulip_phyaddr = mi->mi_phyaddr;
2510 dp0 = &sc->tulip_rombuf[mi->mi_gpr_offset];
2511 for (idx3 = 0; idx3 < mi->mi_gpr_length; idx3++, dp0 += 2) {
2512 DELAY(10);
2513 TULIP_CSR_WRITE(sc, csr_sia_general, (dp0[0] + 256 * dp0[1]) << 16);
2514 }
2515
2516 if (mi->mi_reset_length == 0 && mi->mi_gpr_length == 0)
2517 TULIP_CSR_WRITE(sc, csr_sia_general, 0);
2518
2519 mi->mi_phyaddr = TULIP_MII_NOPHY;
2520 for (idx3 = 20; idx3 > 0 && mi->mi_phyaddr == TULIP_MII_NOPHY; idx3--) {
2521 DELAY(10000);
2522 mi->mi_phyaddr = tulip_mii_get_phyaddr(sc, phyno);
2523 }
2524 if (mi->mi_phyaddr == TULIP_MII_NOPHY) {
2525 #if defined(TULIP_DEBUG)
2526 printf(TULIP_PRINTF_FMT ": can't find phy %d\n",
2527 TULIP_PRINTF_ARGS, phyno);
2528 #endif
2529 break;
2530 }
2531 sc->tulip_features |= TULIP_HAVE_MII;
2532 mi->mi_capabilities = dp[0] + dp[1] * 256; dp += 2;
2533 mi->mi_advertisement = dp[0] + dp[1] * 256; dp += 2;
2534 mi->mi_full_duplex = dp[0] + dp[1] * 256; dp += 2;
2535 mi->mi_tx_threshold = dp[0] + dp[1] * 256; dp += 2;
2536 mi->mi_mii_interrupt = dp[0] + dp[1] * 256; dp += 2;
2537 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX_FD);
2538 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASETX);
2539 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 100BASET4);
2540 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET_FD);
2541 TULIP_MEDIAINFO_ADD_CAPABILITY(sc, mi, 10BASET);
2542 mi->mi_phyid = (tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDLOW) << 16) |
2543 tulip_mii_readreg(sc, mi->mi_phyaddr, PHYREG_IDHIGH);
2544 mi++;
2545 break;
2546 }
2547 case 4: {
2548 tulip_media_t media;
2549 srom_media = (tulip_srom_media_t) dp[0];
2550 for (idx3 = 0; tulip_srom_mediums[idx3].sm_type != TULIP_MEDIA_UNKNOWN; idx3++) {
2551 if (tulip_srom_mediums[idx3].sm_srom_type == srom_media)
2552 break;
2553 }
2554 media = tulip_srom_mediums[idx3].sm_type;
2555 if (media == TULIP_MEDIA_UNKNOWN)
2556 break;
2557 mi->mi_type = TULIP_MEDIAINFO_SYM;
2558 sc->tulip_mediums[media] = mi;
2559 mi->mi_gpcontrol = (dp[1] + dp[2] * 256) << 16;
2560 mi->mi_gpdata = (dp[3] + dp[4] * 256) << 16;
2561 data = dp[5] + dp[6] * 256;
2562 mi->mi_cmdmode = TULIP_SROM_2114X_CMDBITS(data);
2563 if (data & TULIP_SROM_2114X_NOINDICATOR)
2564 mi->mi_actmask = 0;
2565 else {
2566 mi->mi_default = (data & TULIP_SROM_2114X_DEFAULT) != 0;
2567 mi->mi_actmask = TULIP_SROM_2114X_BITPOS(data);
2568 mi->mi_actdata = (data & TULIP_SROM_2114X_POLARITY) ? 0 : mi->mi_actmask;
2569 }
2570 if (TULIP_IS_MEDIA_TP(media))
2571 sc->tulip_intrmask |= TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL;
2572 mi++;
2573 break;
2574 }
2575 default: {
2576 }
2577 }
2578 dp = ep;
2579 }
2580 }
2581 return (mi - sc->tulip_mediainfo);
2582 }
2583
2584 static const struct {
2585 void (*vendor_identify_nic)(tulip_softc_t * const sc);
2586 unsigned char vendor_oui[3];
2587 } tulip_vendors[] = {
2588 { tulip_identify_dec_nic, { 0x08, 0x00, 0x2B } },
2589 { tulip_identify_dec_nic, { 0x00, 0x00, 0xF8 } },
2590 { tulip_identify_smc_nic, { 0x00, 0x00, 0xC0 } },
2591 { tulip_identify_smc_nic, { 0x00, 0xE0, 0x29 } },
2592 { tulip_identify_znyx_nic, { 0x00, 0xC0, 0x95 } },
2593 { tulip_identify_cogent_nic, { 0x00, 0x00, 0x92 } },
2594 { tulip_identify_cogent_nic, { 0x00, 0x00, 0xD1 } },
2595 { tulip_identify_asante_nic, { 0x00, 0x00, 0x94 } },
2596 { tulip_identify_accton_nic, { 0x00, 0x00, 0xE8 } },
2597 { tulip_identify_compex_nic, { 0x00, 0x80, 0x48 } },
2598 { NULL }
2599 };
2600
2601
2602
2603
2604
2605 int
2606 tulip_read_macaddr(tulip_softc_t * const sc)
2607 {
2608 unsigned cksum, rom_cksum, idx;
2609 u_int32_t csr;
2610 unsigned char tmpbuf[8];
2611 static const u_char testpat[] = { 0xFF, 0, 0x55, 0xAA, 0xFF, 0, 0x55, 0xAA };
2612
2613 sc->tulip_connidx = TULIP_SROM_LASTCONNIDX;
2614
2615 if (sc->tulip_chipid == TULIP_21040) {
2616 TULIP_CSR_WRITE(sc, csr_enetrom, 1);
2617 for (idx = 0; idx < sizeof(sc->tulip_rombuf); idx++) {
2618 int cnt = 0;
2619 while (((csr = TULIP_CSR_READ(sc, csr_enetrom)) & 0x80000000L) && cnt < 10000)
2620 cnt++;
2621 sc->tulip_rombuf[idx] = csr & 0xFF;
2622 }
2623 sc->tulip_boardsw = &tulip_21040_boardsw;
2624 } else {
2625 if (sc->tulip_chipid == TULIP_21041) {
2626
2627
2628
2629 sc->tulip_boardsw = &tulip_21041_boardsw;
2630 } else {
2631
2632
2633
2634
2635
2636
2637
2638 sc->tulip_boardsw = &tulip_21140_eb_boardsw;
2639 }
2640 tulip_srom_read(sc);
2641 if (tulip_srom_crcok(sc->tulip_rombuf)) {
2642
2643
2644
2645
2646 sc->tulip_features |= TULIP_HAVE_ISVSROM|TULIP_HAVE_OKSROM;
2647 } else if (sc->tulip_rombuf[126] == 0xff && sc->tulip_rombuf[127] == 0xFF) {
2648
2649
2650
2651
2652
2653 for (idx = 0; idx < 18; idx++) {
2654 if (sc->tulip_rombuf[idx] != 0)
2655 break;
2656 }
2657 if (idx == 18 && sc->tulip_rombuf[18] == 1 && sc->tulip_rombuf[19] != 0)
2658 sc->tulip_features |= TULIP_HAVE_ISVSROM;
2659 } else if (sc->tulip_chipid >= TULIP_21142) {
2660 sc->tulip_features |= TULIP_HAVE_ISVSROM;
2661 sc->tulip_boardsw = &tulip_2114x_isv_boardsw;
2662 }
2663 if ((sc->tulip_features & TULIP_HAVE_ISVSROM) && tulip_srom_decode(sc)) {
2664 if (sc->tulip_chipid != TULIP_21041)
2665 sc->tulip_boardsw = &tulip_2114x_isv_boardsw;
2666
2667
2668
2669
2670
2671 if (sc->tulip_rombuf[19] > 1)
2672 sc->tulip_features |= TULIP_HAVE_BASEROM;
2673 if (sc->tulip_boardsw == NULL)
2674 return (-6);
2675 goto check_oui;
2676 }
2677 }
2678
2679 if (bcmp(&sc->tulip_rombuf[0], &sc->tulip_rombuf[16], 8) != 0) {
2680
2681
2682
2683
2684
2685
2686
2687 for (idx = 8; idx < 32; idx++) {
2688 if (sc->tulip_rombuf[idx] != 0xFF)
2689 return (-4);
2690 }
2691
2692
2693
2694
2695 if ((sc->tulip_rombuf[0] & 3) != 0)
2696 return (-4);
2697 if (sc->tulip_rombuf[0] == 0 && sc->tulip_rombuf[1] == 0
2698 && sc->tulip_rombuf[2] == 0)
2699 return (-4);
2700 bcopy(sc->tulip_rombuf, sc->tulip_enaddr, ETHER_ADDR_LEN);
2701 sc->tulip_features |= TULIP_HAVE_OKROM;
2702 goto check_oui;
2703 } else {
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714 for (idx = 0; idx < sizeof(sc->tulip_rombuf); idx++) {
2715 if (sc->tulip_rombuf[idx] != 0 && sc->tulip_rombuf[idx] != 0xFF)
2716 break;
2717 }
2718 if (idx == sizeof(sc->tulip_rombuf)) {
2719 int root_unit;
2720 tulip_softc_t *root_sc = NULL;
2721 for (root_unit = sc->tulip_unit - 1; root_unit >= 0; root_unit--) {
2722 root_sc = TULIP_UNIT_TO_SOFTC(root_unit);
2723 if (root_sc == NULL || (root_sc->tulip_features & (TULIP_HAVE_OKROM|TULIP_HAVE_SLAVEDROM)) == TULIP_HAVE_OKROM)
2724 break;
2725 root_sc = NULL;
2726 }
2727 if (root_sc != NULL && (root_sc->tulip_features & TULIP_HAVE_BASEROM)
2728 && root_sc->tulip_chipid == sc->tulip_chipid
2729 && root_sc->tulip_pci_busno == sc->tulip_pci_busno) {
2730 sc->tulip_features |= TULIP_HAVE_SLAVEDROM;
2731 sc->tulip_boardsw = root_sc->tulip_boardsw;
2732 strlcpy(sc->tulip_boardid, root_sc->tulip_boardid,
2733 sizeof(sc->tulip_boardid));
2734 if (sc->tulip_boardsw->bd_type == TULIP_21140_ISV) {
2735 bcopy(root_sc->tulip_rombuf, sc->tulip_rombuf,
2736 sizeof(sc->tulip_rombuf));
2737 if (!tulip_srom_decode(sc))
2738 return (-5);
2739 } else {
2740 bcopy(root_sc->tulip_enaddr, sc->tulip_enaddr,
2741 ETHER_ADDR_LEN);
2742 sc->tulip_enaddr[5] += sc->tulip_unit - root_sc->tulip_unit;
2743 }
2744
2745
2746
2747
2748
2749
2750
2751 if (root_sc->tulip_features & TULIP_HAVE_SHAREDINTR) {
2752 sc->tulip_slaves = root_sc->tulip_slaves;
2753 root_sc->tulip_slaves = sc;
2754 sc->tulip_features |= TULIP_HAVE_SLAVEDINTR;
2755 }
2756 return (0);
2757 }
2758 }
2759 }
2760
2761
2762
2763
2764
2765 if (bcmp(&sc->tulip_rombuf[24], testpat, 8) != 0)
2766 return (-3);
2767
2768 tmpbuf[0] = sc->tulip_rombuf[15]; tmpbuf[1] = sc->tulip_rombuf[14];
2769 tmpbuf[2] = sc->tulip_rombuf[13]; tmpbuf[3] = sc->tulip_rombuf[12];
2770 tmpbuf[4] = sc->tulip_rombuf[11]; tmpbuf[5] = sc->tulip_rombuf[10];
2771 tmpbuf[6] = sc->tulip_rombuf[9]; tmpbuf[7] = sc->tulip_rombuf[8];
2772 if (bcmp(&sc->tulip_rombuf[0], tmpbuf, 8) != 0)
2773 return (-2);
2774
2775 bcopy(sc->tulip_rombuf, sc->tulip_enaddr, ETHER_ADDR_LEN);
2776
2777 cksum = *(u_int16_t *) &sc->tulip_enaddr[0];
2778 cksum *= 2;
2779 if (cksum > 65535) cksum -= 65535;
2780 cksum += *(u_int16_t *) &sc->tulip_enaddr[2];
2781 if (cksum > 65535) cksum -= 65535;
2782 cksum *= 2;
2783 if (cksum > 65535) cksum -= 65535;
2784 cksum += *(u_int16_t *) &sc->tulip_enaddr[4];
2785 if (cksum >= 65535) cksum -= 65535;
2786
2787 rom_cksum = *(u_int16_t *) &sc->tulip_rombuf[6];
2788
2789 if (cksum != rom_cksum)
2790 return (-1);
2791
2792 check_oui:
2793
2794
2795
2796 for (idx = 0; tulip_vendors[idx].vendor_identify_nic != NULL; idx++) {
2797 if (bcmp((caddr_t) sc->tulip_enaddr,
2798 (caddr_t) tulip_vendors[idx].vendor_oui, 3) == 0) {
2799 (*tulip_vendors[idx].vendor_identify_nic)(sc);
2800 break;
2801 }
2802 }
2803
2804 sc->tulip_features |= TULIP_HAVE_OKROM;
2805 return (0);
2806 }
2807
2808 void
2809 tulip_ifmedia_add(tulip_softc_t * const sc)
2810 {
2811 tulip_media_t media;
2812 int medias = 0;
2813
2814 for (media = TULIP_MEDIA_UNKNOWN; media < TULIP_MEDIA_MAX; media++) {
2815 if (sc->tulip_mediums[media] != NULL) {
2816 ifmedia_add(&sc->tulip_ifmedia, tulip_media_to_ifmedia[media],
2817 0, 0);
2818 medias++;
2819 }
2820 }
2821 if (medias == 0) {
2822 sc->tulip_features |= TULIP_HAVE_NOMEDIA;
2823 ifmedia_add(&sc->tulip_ifmedia, IFM_ETHER | IFM_NONE, 0, 0);
2824 ifmedia_set(&sc->tulip_ifmedia, IFM_ETHER | IFM_NONE);
2825 } else if (sc->tulip_media == TULIP_MEDIA_UNKNOWN) {
2826 ifmedia_add(&sc->tulip_ifmedia, IFM_ETHER | IFM_AUTO, 0, 0);
2827 ifmedia_set(&sc->tulip_ifmedia, IFM_ETHER | IFM_AUTO);
2828 } else {
2829 ifmedia_set(&sc->tulip_ifmedia, tulip_media_to_ifmedia[sc->tulip_media]);
2830 sc->tulip_flags |= TULIP_PRINTMEDIA;
2831 tulip_linkup(sc, sc->tulip_media);
2832 }
2833 }
2834
2835 int
2836 tulip_ifmedia_change(struct ifnet * const ifp)
2837 {
2838 tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
2839
2840 sc->tulip_flags |= TULIP_NEEDRESET;
2841 sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
2842 sc->tulip_media = TULIP_MEDIA_UNKNOWN;
2843 if (IFM_SUBTYPE(sc->tulip_ifmedia.ifm_media) != IFM_AUTO) {
2844 tulip_media_t media;
2845 for (media = TULIP_MEDIA_UNKNOWN; media < TULIP_MEDIA_MAX; media++) {
2846 if (sc->tulip_mediums[media] != NULL
2847 && sc->tulip_ifmedia.ifm_media == tulip_media_to_ifmedia[media]) {
2848 sc->tulip_flags |= TULIP_PRINTMEDIA;
2849 sc->tulip_flags &= ~TULIP_DIDNWAY;
2850 tulip_linkup(sc, media);
2851 return (0);
2852 }
2853 }
2854 }
2855 sc->tulip_flags &= ~(TULIP_TXPROBE_ACTIVE|TULIP_WANTRXACT);
2856 tulip_reset(sc);
2857 tulip_init(sc);
2858 return (0);
2859 }
2860
2861
2862
2863
2864 void
2865 tulip_ifmedia_status(struct ifnet * const ifp, struct ifmediareq *req)
2866 {
2867 tulip_softc_t *sc = TULIP_IFP_TO_SOFTC(ifp);
2868
2869 if (sc->tulip_media == TULIP_MEDIA_UNKNOWN)
2870 return;
2871
2872 req->ifm_status = IFM_AVALID;
2873 if (sc->tulip_flags & TULIP_LINKUP)
2874 req->ifm_status |= IFM_ACTIVE;
2875
2876 req->ifm_active = tulip_media_to_ifmedia[sc->tulip_media];
2877 }
2878
2879 void
2880 tulip_addr_filter(tulip_softc_t * const sc)
2881 {
2882 struct ether_multistep step;
2883 struct ether_multi *enm;
2884
2885 sc->tulip_flags &= ~(TULIP_WANTHASHPERFECT|TULIP_WANTHASHONLY|TULIP_ALLMULTI);
2886 sc->tulip_flags |= TULIP_WANTSETUP|TULIP_WANTTXSTART;
2887 sc->tulip_cmdmode &= ~TULIP_CMD_RXRUN;
2888 sc->tulip_intrmask &= ~TULIP_STS_RXSTOPPED;
2889 sc->tulip_if.if_flags &= ~IFF_ALLMULTI;
2890 sc->tulip_if.if_start = tulip_ifstart;
2891 if (sc->tulip_multicnt > 14) {
2892 u_int32_t *sp = sc->tulip_setupdata;
2893 unsigned hash;
2894
2895
2896
2897
2898
2899
2900
2901 if (sc->tulip_features & TULIP_HAVE_BROKEN_HASH)
2902 sc->tulip_flags |= TULIP_WANTHASHONLY;
2903 else
2904 sc->tulip_flags |= TULIP_WANTHASHPERFECT;
2905
2906
2907
2908
2909
2910 bzero(sc->tulip_setupdata, sizeof(sc->tulip_setupdata));
2911 ETHER_FIRST_MULTI(step, &sc->tulip_ac, enm);
2912 while (enm != NULL) {
2913 if (bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) == 0) {
2914 hash = tulip_mchash(enm->enm_addrlo);
2915 #if BYTE_ORDER == BIG_ENDIAN
2916 sp[hash >> 4] |= swap32(1 << (hash & 0xF));
2917 #else
2918 sp[hash >> 4] |= 1 << (hash & 0xF);
2919 #endif
2920 } else {
2921 sc->tulip_flags |= TULIP_ALLMULTI;
2922 sc->tulip_flags &= ~(TULIP_WANTHASHONLY|TULIP_WANTHASHPERFECT);
2923 break;
2924 }
2925 ETHER_NEXT_MULTI(step, enm);
2926 }
2927
2928
2929
2930
2931 if ((sc->tulip_flags & TULIP_ALLMULTI) == 0) {
2932 hash = tulip_mchash(etherbroadcastaddr);
2933 #if BYTE_ORDER == BIG_ENDIAN
2934 sp[hash >> 4] |= swap32(1 << (hash & 0xF));
2935 #else
2936 sp[hash >> 4] |= 1 << (hash & 0xF);
2937 #endif
2938 if (sc->tulip_flags & TULIP_WANTHASHONLY) {
2939 hash = tulip_mchash(sc->tulip_enaddr);
2940 #if BYTE_ORDER == BIG_ENDIAN
2941 sp[hash >> 4] |= swap32(1 << (hash & 0xF));
2942 #else
2943 sp[hash >> 4] |= 1 << (hash & 0xF);
2944 #endif
2945 } else {
2946 #if BYTE_ORDER == BIG_ENDIAN
2947 sp[39] = ((u_int16_t *) sc->tulip_enaddr)[0] << 16;
2948 sp[40] = ((u_int16_t *) sc->tulip_enaddr)[1] << 16;
2949 sp[41] = ((u_int16_t *) sc->tulip_enaddr)[2] << 16;
2950 #else
2951 sp[39] = ((u_int16_t *) sc->tulip_enaddr)[0];
2952 sp[40] = ((u_int16_t *) sc->tulip_enaddr)[1];
2953 sp[41] = ((u_int16_t *) sc->tulip_enaddr)[2];
2954 #endif
2955 }
2956 }
2957 }
2958 if ((sc->tulip_flags & (TULIP_WANTHASHPERFECT|TULIP_WANTHASHONLY)) == 0) {
2959 u_int32_t *sp = sc->tulip_setupdata;
2960 int idx = 0;
2961 if ((sc->tulip_flags & TULIP_ALLMULTI) == 0) {
2962
2963
2964
2965 ETHER_FIRST_MULTI(step, &sc->tulip_ac, enm);
2966 for (; enm != NULL; idx++) {
2967 if (bcmp(enm->enm_addrlo, enm->enm_addrhi, 6) == 0) {
2968 #if BYTE_ORDER == BIG_ENDIAN
2969 *sp++ = ((u_int16_t *) enm->enm_addrlo)[0] << 16;
2970 *sp++ = ((u_int16_t *) enm->enm_addrlo)[1] << 16;
2971 *sp++ = ((u_int16_t *) enm->enm_addrlo)[2] << 16;
2972 #else
2973 *sp++ = ((u_int16_t *) enm->enm_addrlo)[0];
2974 *sp++ = ((u_int16_t *) enm->enm_addrlo)[1];
2975 *sp++ = ((u_int16_t *) enm->enm_addrlo)[2];
2976 #endif
2977 } else {
2978 sc->tulip_flags |= TULIP_ALLMULTI;
2979 break;
2980 }
2981 ETHER_NEXT_MULTI(step, enm);
2982 }
2983
2984
2985
2986 idx++;
2987 #if BYTE_ORDER == BIG_ENDIAN
2988 *sp++ = 0xFFFF << 16;
2989 *sp++ = 0xFFFF << 16;
2990 *sp++ = 0xFFFF << 16;
2991 #else
2992 *sp++ = 0xFFFF;
2993 *sp++ = 0xFFFF;
2994 *sp++ = 0xFFFF;
2995 #endif
2996 }
2997
2998
2999
3000 for (; idx < 16; idx++) {
3001 #if BYTE_ORDER == BIG_ENDIAN
3002 *sp++ = ((u_int16_t *) sc->tulip_enaddr)[0] << 16;
3003 *sp++ = ((u_int16_t *) sc->tulip_enaddr)[1] << 16;
3004 *sp++ = ((u_int16_t *) sc->tulip_enaddr)[2] << 16;
3005 #else
3006 *sp++ = ((u_int16_t *) sc->tulip_enaddr)[0];
3007 *sp++ = ((u_int16_t *) sc->tulip_enaddr)[1];
3008 *sp++ = ((u_int16_t *) sc->tulip_enaddr)[2];
3009 #endif
3010 }
3011 }
3012 if (sc->tulip_flags & TULIP_ALLMULTI)
3013 sc->tulip_if.if_flags |= IFF_ALLMULTI;
3014 }
3015
3016 void
3017 tulip_reset(tulip_softc_t * const sc)
3018 {
3019 tulip_ringinfo_t *ri;
3020 tulip_desc_t *di;
3021 u_int32_t inreset = (sc->tulip_flags & TULIP_INRESET);
3022
3023
3024
3025
3026
3027
3028
3029
3030 if ((sc->tulip_flags & TULIP_DEVICEPROBE) == 0
3031 && sc->tulip_boardsw->bd_media_preset != NULL)
3032 (*sc->tulip_boardsw->bd_media_preset)(sc);
3033
3034 TULIP_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
3035 DELAY(10);
3036
3037
3038
3039 if (!inreset) {
3040 sc->tulip_flags |= TULIP_INRESET;
3041 sc->tulip_flags &= ~(TULIP_NEEDRESET|TULIP_RXBUFSLOW);
3042 sc->tulip_if.if_flags &= ~IFF_OACTIVE;
3043 sc->tulip_if.if_start = tulip_ifstart;
3044 }
3045
3046 TULIP_CSR_WRITE(sc, csr_txlist, sc->tulip_txdescmap->dm_segs[0].ds_addr);
3047 TULIP_CSR_WRITE(sc, csr_rxlist, sc->tulip_rxdescmap->dm_segs[0].ds_addr);
3048 TULIP_CSR_WRITE(sc, csr_busmode,
3049 (1 << (TULIP_BURSTSIZE(sc->tulip_unit) + 8))
3050 |TULIP_BUSMODE_CACHE_ALIGN8
3051 |TULIP_BUSMODE_READMULTIPLE
3052 |(BYTE_ORDER != LITTLE_ENDIAN ?
3053 TULIP_BUSMODE_DESC_BIGENDIAN : 0));
3054
3055 sc->tulip_txtimer = 0;
3056 sc->tulip_txq.ifq_maxlen = TULIP_TXDESCS;
3057
3058
3059
3060 for (;;) {
3061 bus_dmamap_t map;
3062 struct mbuf *m;
3063 IF_DEQUEUE(&sc->tulip_txq, m);
3064 if (m == NULL)
3065 break;
3066 map = TULIP_GETCTX(m, bus_dmamap_t);
3067 bus_dmamap_unload(sc->tulip_dmatag, map);
3068 sc->tulip_txmaps[sc->tulip_txmaps_free++] = map;
3069 m_freem(m);
3070 }
3071
3072 ri = &sc->tulip_txinfo;
3073 ri->ri_nextin = ri->ri_nextout = ri->ri_first;
3074 ri->ri_free = ri->ri_max;
3075 for (di = ri->ri_first; di < ri->ri_last; di++)
3076 di->d_status = 0;
3077 bus_dmamap_sync(sc->tulip_dmatag, sc->tulip_txdescmap,
3078 0, sc->tulip_txdescmap->dm_mapsize,
3079 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
3080
3081
3082
3083
3084
3085
3086
3087 ri = &sc->tulip_rxinfo;
3088 ri->ri_nextin = ri->ri_nextout = ri->ri_first;
3089 ri->ri_free = ri->ri_max;
3090 for (di = ri->ri_first; di < ri->ri_last; di++) {
3091 di->d_status = 0;
3092 di->d_length1 = 0; di->d_addr1 = 0;
3093 di->d_length2 = 0; di->d_addr2 = 0;
3094 }
3095 bus_dmamap_sync(sc->tulip_dmatag, sc->tulip_rxdescmap,
3096 0, sc->tulip_rxdescmap->dm_mapsize,
3097 BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
3098 for (;;) {
3099 bus_dmamap_t map;
3100 struct mbuf *m;
3101 IF_DEQUEUE(&sc->tulip_rxq, m);
3102 if (m == NULL)
3103 break;
3104 map = TULIP_GETCTX(m, bus_dmamap_t);
3105 bus_dmamap_unload(sc->tulip_dmatag, map);
3106 sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
3107 m_freem(m);
3108 }
3109
3110
3111
3112
3113
3114
3115 if (inreset)
3116 return;
3117
3118 sc->tulip_intrmask |= TULIP_STS_NORMALINTR|TULIP_STS_RXINTR|TULIP_STS_TXINTR
3119 |TULIP_STS_ABNRMLINTR|TULIP_STS_SYSERROR|TULIP_STS_TXSTOPPED
3120 |TULIP_STS_TXUNDERFLOW|TULIP_STS_TXBABBLE
3121 |TULIP_STS_RXSTOPPED;
3122
3123 if ((sc->tulip_flags & TULIP_DEVICEPROBE) == 0)
3124 (*sc->tulip_boardsw->bd_media_select)(sc);
3125 #if defined(TULIP_DEBUG)
3126 if ((sc->tulip_flags & TULIP_NEEDRESET) == TULIP_NEEDRESET)
3127 printf(TULIP_PRINTF_FMT ": tulip_reset: additional reset needed?!?\n",
3128 TULIP_PRINTF_ARGS);
3129 #endif
3130 tulip_media_print(sc);
3131 if (sc->tulip_features & TULIP_HAVE_DUALSENSE)
3132 TULIP_CSR_WRITE(sc, csr_sia_status, TULIP_CSR_READ(sc, csr_sia_status));
3133
3134 sc->tulip_flags &= ~(TULIP_DOINGSETUP|TULIP_WANTSETUP|TULIP_INRESET
3135 |TULIP_RXACT);
3136 tulip_addr_filter(sc);
3137 }
3138
3139 void
3140 tulip_init(tulip_softc_t * const sc)
3141 {
3142 if (sc->tulip_if.if_flags & IFF_UP) {
3143 if ((sc->tulip_if.if_flags & IFF_RUNNING) == 0) {
3144
3145 tulip_reset(sc);
3146 }
3147 sc->tulip_if.if_flags |= IFF_RUNNING;
3148 if (sc->tulip_if.if_flags & IFF_PROMISC) {
3149 sc->tulip_flags |= TULIP_PROMISC;
3150 sc->tulip_cmdmode |= TULIP_CMD_PROMISCUOUS;
3151 sc->tulip_intrmask |= TULIP_STS_TXINTR;
3152 } else {
3153 sc->tulip_flags &= ~TULIP_PROMISC;
3154 sc->tulip_cmdmode &= ~TULIP_CMD_PROMISCUOUS;
3155 if (sc->tulip_flags & TULIP_ALLMULTI)
3156 sc->tulip_cmdmode |= TULIP_CMD_ALLMULTI;
3157 else
3158 sc->tulip_cmdmode &= ~TULIP_CMD_ALLMULTI;
3159 }
3160 sc->tulip_cmdmode |= TULIP_CMD_TXRUN;
3161 if ((sc->tulip_flags & (TULIP_TXPROBE_ACTIVE|TULIP_WANTSETUP)) == 0) {
3162 tulip_rx_intr(sc);
3163 sc->tulip_cmdmode |= TULIP_CMD_RXRUN;
3164 sc->tulip_intrmask |= TULIP_STS_RXSTOPPED;
3165 } else {
3166 sc->tulip_if.if_flags |= IFF_OACTIVE;
3167 sc->tulip_cmdmode &= ~TULIP_CMD_RXRUN;
3168 sc->tulip_intrmask &= ~TULIP_STS_RXSTOPPED;
3169 }
3170 TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
3171 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
3172 if ((sc->tulip_flags & (TULIP_WANTSETUP|TULIP_TXPROBE_ACTIVE)) == TULIP_WANTSETUP)
3173 tulip_txput_setup(sc);
3174 } else {
3175 sc->tulip_if.if_flags &= ~IFF_RUNNING;
3176 tulip_reset(sc);
3177 }
3178 }
3179
3180 void
3181 tulip_rx_intr(tulip_softc_t * const sc)
3182 {
3183 TULIP_PERFSTART(rxintr)
3184 tulip_ringinfo_t * const ri = &sc->tulip_rxinfo;
3185 struct ifnet * const ifp = &sc->tulip_if;
3186 int fillok = 1;
3187 #if defined(TULIP_DEBUG)
3188 int cnt = 0;
3189 #endif
3190
3191 for (;;) {
3192 TULIP_PERFSTART(rxget)
3193 tulip_desc_t *eop = ri->ri_nextin;
3194 int total_len = 0, last_offset = 0;
3195 struct mbuf *ms = NULL, *me = NULL;
3196 int accept = 0;
3197 bus_dmamap_t map;
3198 int error;
3199
3200 if (fillok && sc->tulip_rxq.ifq_len < TULIP_RXQ_TARGET)
3201 goto queue_mbuf;
3202
3203 #if defined(TULIP_DEBUG)
3204 if (cnt == ri->ri_max)
3205 break;
3206 #endif
3207
3208
3209
3210
3211 if (eop == ri->ri_nextout)
3212 break;
3213
3214
3215
3216
3217
3218 TULIP_RXDESC_POSTSYNC(sc, eop, sizeof(*eop));
3219 if ((((volatile tulip_desc_t *) eop)->d_status & (TULIP_DSTS_OWNER|TULIP_DSTS_RxFIRSTDESC|TULIP_DSTS_RxLASTDESC)) == (TULIP_DSTS_RxFIRSTDESC|TULIP_DSTS_RxLASTDESC)) {
3220 IF_DEQUEUE(&sc->tulip_rxq, ms);
3221 me = ms;
3222 } else {
3223
3224
3225
3226 if (((volatile tulip_desc_t *) eop)->d_status & TULIP_DSTS_OWNER)
3227 break;
3228
3229
3230
3231
3232
3233 while ((((volatile tulip_desc_t *) eop)->d_status & TULIP_DSTS_RxLASTDESC) == 0) {
3234 if (++eop == ri->ri_last)
3235 eop = ri->ri_first;
3236 TULIP_RXDESC_POSTSYNC(sc, eop, sizeof(*eop));
3237 if (eop == ri->ri_nextout || ((((volatile tulip_desc_t *) eop)->d_status & TULIP_DSTS_OWNER))) {
3238 #if defined(TULIP_DEBUG)
3239 sc->tulip_dbg.dbg_rxintrs++;
3240 sc->tulip_dbg.dbg_rxpktsperintr[cnt]++;
3241 #endif
3242 TULIP_PERFEND(rxget);
3243 TULIP_PERFEND(rxintr);
3244 return;
3245 }
3246 total_len++;
3247 }
3248
3249
3250
3251
3252
3253
3254
3255
3256
3257
3258
3259 IF_DEQUEUE(&sc->tulip_rxq, ms);
3260 for (me = ms; total_len > 0; total_len--) {
3261 map = TULIP_GETCTX(me, bus_dmamap_t);
3262 TULIP_RXMAP_POSTSYNC(sc, map);
3263 bus_dmamap_unload(sc->tulip_dmatag, map);
3264 sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
3265 #if defined(DIAGNOSTIC)
3266 TULIP_SETCTX(me, NULL);
3267 #endif
3268 me->m_len = TULIP_RX_BUFLEN;
3269 last_offset += TULIP_RX_BUFLEN;
3270 IF_DEQUEUE(&sc->tulip_rxq, me->m_next);
3271 me = me->m_next;
3272 }
3273 }
3274
3275
3276
3277
3278 total_len = ((eop->d_status >> 16) & 0x7FFF) - 4;
3279 if ((sc->tulip_flags & TULIP_RXIGNORE) == 0
3280 && ((eop->d_status & TULIP_DSTS_ERRSUM) == 0)) {
3281 me->m_len = total_len - last_offset;
3282
3283 map = TULIP_GETCTX(me, bus_dmamap_t);
3284 bus_dmamap_sync(sc->tulip_dmatag, map, 0, me->m_len,
3285 BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
3286 bus_dmamap_unload(sc->tulip_dmatag, map);
3287 sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
3288 #if defined(DIAGNOSTIC)
3289 TULIP_SETCTX(me, NULL);
3290 #endif
3291
3292 #if NBPFILTER > 0
3293 if (sc->tulip_bpf != NULL) {
3294 if (me == ms) {
3295 bpf_tap(sc->tulip_if.if_bpf, mtod(ms, caddr_t),
3296 total_len, BPF_DIRECTION_IN);
3297 } else
3298 bpf_mtap(sc->tulip_if.if_bpf, ms, BPF_DIRECTION_IN);
3299 }
3300 #endif
3301 sc->tulip_flags |= TULIP_RXACT;
3302 accept = 1;
3303 } else {
3304 ifp->if_ierrors++;
3305 if (eop->d_status & (TULIP_DSTS_RxBADLENGTH|TULIP_DSTS_RxOVERFLOW|TULIP_DSTS_RxWATCHDOG))
3306 sc->tulip_dot3stats.dot3StatsInternalMacReceiveErrors++;
3307 else {
3308 #ifdef TULIP_DEBUG
3309 const char *error = NULL;
3310 if (eop->d_status & TULIP_DSTS_RxTOOLONG) {
3311 sc->tulip_dot3stats.dot3StatsFrameTooLongs++;
3312 error = "frame too long";
3313 }
3314 if (eop->d_status & TULIP_DSTS_RxBADCRC) {
3315 if (eop->d_status & TULIP_DSTS_RxDRBBLBIT) {
3316 sc->tulip_dot3stats.dot3StatsAlignmentErrors++;
3317 error = "alignment error";
3318 } else {
3319 sc->tulip_dot3stats.dot3StatsFCSErrors++;
3320 error = "bad crc";
3321 }
3322 }
3323 if (error != NULL && (sc->tulip_flags & TULIP_NOMESSAGES) == 0) {
3324 printf(TULIP_PRINTF_FMT ": receive: %s: %s\n",
3325 TULIP_PRINTF_ARGS,
3326 ether_sprintf(mtod(ms, u_char *) + 6),
3327 error);
3328 sc->tulip_flags |= TULIP_NOMESSAGES;
3329 }
3330 #endif
3331 }
3332
3333 map = TULIP_GETCTX(me, bus_dmamap_t);
3334 bus_dmamap_unload(sc->tulip_dmatag, map);
3335 sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
3336 #if defined(DIAGNOSTIC)
3337 TULIP_SETCTX(me, NULL);
3338 #endif
3339 }
3340 #if defined(TULIP_DEBUG)
3341 cnt++;
3342 #endif
3343 ifp->if_ipackets++;
3344 if (++eop == ri->ri_last)
3345 eop = ri->ri_first;
3346 ri->ri_nextin = eop;
3347 queue_mbuf:
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361 if (accept || ms == NULL) {
3362 struct mbuf *m0;
3363 MGETHDR(m0, M_DONTWAIT, MT_DATA);
3364 if (m0 != NULL) {
3365 #if defined(TULIP_COPY_RXDATA)
3366 if (!accept || total_len >= (MHLEN - 2)) {
3367 #endif
3368 MCLGET(m0, M_DONTWAIT);
3369 if ((m0->m_flags & M_EXT) == 0) {
3370 m_freem(m0);
3371 m0 = NULL;
3372 }
3373 #if defined(TULIP_COPY_RXDATA)
3374 }
3375 #endif
3376 }
3377 if (accept
3378 #if defined(TULIP_COPY_RXDATA)
3379 && m0 != NULL
3380 #endif
3381 ) {
3382 #if !defined(TULIP_COPY_RXDATA)
3383 ms->m_pkthdr.len = total_len;
3384 ms->m_pkthdr.rcvif = ifp;
3385 ether_input_mbuf(ifp, ms);
3386 #else
3387 m0->m_data += 2;
3388 m_copydata(ms, 0, total_len, mtod(m0, caddr_t));
3389 m0->m_len = m0->m_pkthdr.len = total_len;
3390 m0->m_pkthdr.rcvif = ifp;
3391 ether_input_mbuf(ifp, m0);
3392 m0 = ms;
3393 #endif
3394 }
3395 ms = m0;
3396 }
3397 if (ms == NULL) {
3398
3399
3400
3401
3402 fillok = 0;
3403 sc->tulip_flags |= TULIP_RXBUFSLOW;
3404 #if defined(TULIP_DEBUG)
3405 sc->tulip_dbg.dbg_rxlowbufs++;
3406 #endif
3407 TULIP_PERFEND(rxget);
3408 continue;
3409 }
3410
3411
3412
3413
3414 do {
3415 tulip_desc_t * const nextout = ri->ri_nextout;
3416 if (sc->tulip_rxmaps_free > 0)
3417 map = sc->tulip_rxmaps[--sc->tulip_rxmaps_free];
3418 else {
3419 m_freem(ms);
3420 sc->tulip_flags |= TULIP_RXBUFSLOW;
3421 #if defined(TULIP_DEBUG)
3422 sc->tulip_dbg.dbg_rxlowbufs++;
3423 #endif
3424 break;
3425 }
3426 TULIP_SETCTX(ms, map);
3427 error = bus_dmamap_load(sc->tulip_dmatag, map, mtod(ms, void *),
3428 TULIP_RX_BUFLEN, NULL, BUS_DMA_NOWAIT);
3429 if (error) {
3430 printf(TULIP_PRINTF_FMT ": unable to load rx map, "
3431 "error = %d\n", TULIP_PRINTF_ARGS, error);
3432 panic("tulip_rx_intr");
3433 }
3434 nextout->d_addr1 = map->dm_segs[0].ds_addr;
3435 nextout->d_length1 = map->dm_segs[0].ds_len;
3436 if (map->dm_nsegs == 2) {
3437 nextout->d_addr2 = map->dm_segs[1].ds_addr;
3438 nextout->d_length2 = map->dm_segs[1].ds_len;
3439 } else {
3440 nextout->d_addr2 = 0;
3441 nextout->d_length2 = 0;
3442 }
3443 TULIP_RXDESC_POSTSYNC(sc, nextout, sizeof(*nextout));
3444 nextout->d_status = TULIP_DSTS_OWNER;
3445 TULIP_RXDESC_POSTSYNC(sc, nextout, sizeof(u_int32_t));
3446 if (++ri->ri_nextout == ri->ri_last)
3447 ri->ri_nextout = ri->ri_first;
3448 me = ms->m_next;
3449 ms->m_next = NULL;
3450 IF_ENQUEUE(&sc->tulip_rxq, ms);
3451 } while ((ms = me) != NULL);
3452
3453 if (sc->tulip_rxq.ifq_len >= TULIP_RXQ_TARGET)
3454 sc->tulip_flags &= ~TULIP_RXBUFSLOW;
3455 TULIP_PERFEND(rxget);
3456 }
3457
3458 #if defined(TULIP_DEBUG)
3459 sc->tulip_dbg.dbg_rxintrs++;
3460 sc->tulip_dbg.dbg_rxpktsperintr[cnt]++;
3461 #endif
3462 TULIP_PERFEND(rxintr);
3463 }
3464
3465 int
3466 tulip_tx_intr(tulip_softc_t * const sc)
3467 {
3468 TULIP_PERFSTART(txintr)
3469 tulip_ringinfo_t * const ri = &sc->tulip_txinfo;
3470 struct mbuf *m;
3471 int xmits = 0;
3472 int descs = 0;
3473
3474 while (ri->ri_free < ri->ri_max) {
3475 u_int32_t d_flag;
3476
3477 TULIP_TXDESC_POSTSYNC(sc, ri->ri_nextin, sizeof(*ri->ri_nextin));
3478 if (((volatile tulip_desc_t *) ri->ri_nextin)->d_status & TULIP_DSTS_OWNER)
3479 break;
3480
3481 ri->ri_free++;
3482 descs++;
3483 d_flag = ri->ri_nextin->d_flag;
3484 if (d_flag & TULIP_DFLAG_TxLASTSEG) {
3485 if (d_flag & TULIP_DFLAG_TxSETUPPKT) {
3486
3487
3488
3489
3490
3491
3492
3493 TULIP_TXMAP_POSTSYNC(sc, sc->tulip_setupmap);
3494 sc->tulip_flags &= ~(TULIP_DOINGSETUP|TULIP_HASHONLY);
3495 if (ri->ri_nextin->d_flag & TULIP_DFLAG_TxINVRSFILT)
3496 sc->tulip_flags |= TULIP_HASHONLY;
3497 if ((sc->tulip_flags & (TULIP_WANTSETUP|TULIP_TXPROBE_ACTIVE)) == 0) {
3498 tulip_rx_intr(sc);
3499 sc->tulip_cmdmode |= TULIP_CMD_RXRUN;
3500 sc->tulip_intrmask |= TULIP_STS_RXSTOPPED;
3501 TULIP_CSR_WRITE(sc, csr_status, TULIP_STS_RXSTOPPED);
3502 TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
3503 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
3504 }
3505 } else {
3506 const u_int32_t d_status = ri->ri_nextin->d_status;
3507 IF_DEQUEUE(&sc->tulip_txq, m);
3508 if (m != NULL) {
3509 bus_dmamap_t map = TULIP_GETCTX(m, bus_dmamap_t);
3510 TULIP_TXMAP_POSTSYNC(sc, map);
3511 sc->tulip_txmaps[sc->tulip_txmaps_free++] = map;
3512 #if NBPFILTER > 0
3513 if (sc->tulip_bpf != NULL)
3514 bpf_mtap(sc->tulip_if.if_bpf, m, BPF_DIRECTION_OUT);
3515 #endif
3516 m_freem(m);
3517 }
3518 if (sc->tulip_flags & TULIP_TXPROBE_ACTIVE) {
3519 tulip_mediapoll_event_t event = TULIP_MEDIAPOLL_TXPROBE_OK;
3520 if (d_status & (TULIP_DSTS_TxNOCARR|TULIP_DSTS_TxEXCCOLL)) {
3521 #if defined(TULIP_DEBUG)
3522 if (d_status & TULIP_DSTS_TxNOCARR)
3523 sc->tulip_dbg.dbg_txprobe_nocarr++;
3524 if (d_status & TULIP_DSTS_TxEXCCOLL)
3525 sc->tulip_dbg.dbg_txprobe_exccoll++;
3526 #endif
3527 event = TULIP_MEDIAPOLL_TXPROBE_FAILED;
3528 }
3529 (*sc->tulip_boardsw->bd_media_poll)(sc, event);
3530
3531
3532
3533 break;
3534 } else {
3535 xmits++;
3536 if (d_status & TULIP_DSTS_ERRSUM) {
3537 sc->tulip_if.if_oerrors++;
3538 if (d_status & TULIP_DSTS_TxEXCCOLL)
3539 sc->tulip_dot3stats.dot3StatsExcessiveCollisions++;
3540 if (d_status & TULIP_DSTS_TxLATECOLL)
3541 sc->tulip_dot3stats.dot3StatsLateCollisions++;
3542 if (d_status & (TULIP_DSTS_TxNOCARR|TULIP_DSTS_TxCARRLOSS))
3543 sc->tulip_dot3stats.dot3StatsCarrierSenseErrors++;
3544 if (d_status & (TULIP_DSTS_TxUNDERFLOW|TULIP_DSTS_TxBABBLE))
3545 sc->tulip_dot3stats.dot3StatsInternalMacTransmitErrors++;
3546 if (d_status & TULIP_DSTS_TxUNDERFLOW)
3547 sc->tulip_dot3stats.dot3StatsInternalTransmitUnderflows++;
3548 if (d_status & TULIP_DSTS_TxBABBLE)
3549 sc->tulip_dot3stats.dot3StatsInternalTransmitBabbles++;
3550 } else {
3551 u_int32_t collisions =
3552 (d_status & TULIP_DSTS_TxCOLLMASK)
3553 >> TULIP_DSTS_V_TxCOLLCNT;
3554 sc->tulip_if.if_collisions += collisions;
3555 if (collisions == 1)
3556 sc->tulip_dot3stats.dot3StatsSingleCollisionFrames++;
3557 else if (collisions > 1)
3558 sc->tulip_dot3stats.dot3StatsMultipleCollisionFrames++;
3559 else if (d_status & TULIP_DSTS_TxDEFERRED)
3560 sc->tulip_dot3stats.dot3StatsDeferredTransmissions++;
3561
3562
3563
3564
3565
3566
3567 if (d_status & TULIP_DSTS_TxNOHRTBT & sc->tulip_flags)
3568 sc->tulip_dot3stats.dot3StatsSQETestErrors++;
3569 }
3570 }
3571 }
3572 }
3573
3574 if (++ri->ri_nextin == ri->ri_last)
3575 ri->ri_nextin = ri->ri_first;
3576
3577 if ((sc->tulip_flags & TULIP_TXPROBE_ACTIVE) == 0)
3578 sc->tulip_if.if_flags &= ~IFF_OACTIVE;
3579 }
3580
3581
3582
3583
3584 if (ri->ri_free == ri->ri_max || (sc->tulip_flags & TULIP_TXPROBE_ACTIVE))
3585 sc->tulip_txtimer = 0;
3586 else if (xmits > 0)
3587 sc->tulip_txtimer = TULIP_TXTIMER;
3588 sc->tulip_if.if_opackets += xmits;
3589 TULIP_PERFEND(txintr);
3590 return (descs);
3591 }
3592
3593 void
3594 tulip_print_abnormal_interrupt(tulip_softc_t * const sc, u_int32_t csr)
3595 {
3596 #ifdef TULIP_DEBUG
3597 const char * const *msgp = tulip_status_bits;
3598 const char *sep;
3599 u_int32_t mask;
3600 const char thrsh[] = "72|128\0\0\0" "96|256\0\0\0" "128|512\0\0" "160|1024\0";
3601
3602 csr &= (1 << (sizeof(tulip_status_bits)/sizeof(tulip_status_bits[0]))) - 1;
3603 printf(TULIP_PRINTF_FMT ": abnormal interrupt:", TULIP_PRINTF_ARGS);
3604 for (sep = " ", mask = 1; mask <= csr; mask <<= 1, msgp++) {
3605 if ((csr & mask) && *msgp != NULL) {
3606 printf("%s%s", sep, *msgp);
3607 if (mask == TULIP_STS_TXUNDERFLOW && (sc->tulip_flags & TULIP_NEWTXTHRESH)) {
3608 sc->tulip_flags &= ~TULIP_NEWTXTHRESH;
3609 if (sc->tulip_cmdmode & TULIP_CMD_STOREFWD)
3610 printf(" (switching to store-and-forward mode)");
3611 else {
3612 printf(" (raising TX threshold to %s)",
3613 &thrsh[9 * ((sc->tulip_cmdmode & TULIP_CMD_THRESHOLDCTL) >> 14)]);
3614 }
3615 }
3616 sep = ", ";
3617 }
3618 }
3619 printf("\n");
3620 #endif
3621 }
3622
3623 void
3624 tulip_intr_handler(tulip_softc_t * const sc, int *progress_p)
3625 {
3626 TULIP_PERFSTART(intr)
3627 u_int32_t csr;
3628
3629 while ((csr = TULIP_CSR_READ(sc, csr_status)) & sc->tulip_intrmask) {
3630 *progress_p = 1;
3631 TULIP_CSR_WRITE(sc, csr_status, csr);
3632
3633 if (csr & TULIP_STS_SYSERROR) {
3634 sc->tulip_last_system_error = (csr & TULIP_STS_ERRORMASK) >> TULIP_STS_ERR_SHIFT;
3635 if (sc->tulip_flags & TULIP_NOMESSAGES)
3636 sc->tulip_flags |= TULIP_SYSTEMERROR;
3637 else {
3638 #if defined(TULIP_DEBUG)
3639 printf(TULIP_PRINTF_FMT ": system error: %s\n",
3640 TULIP_PRINTF_ARGS,
3641 tulip_system_errors[sc->tulip_last_system_error]);
3642 #endif
3643 }
3644 sc->tulip_flags |= TULIP_NEEDRESET;
3645 sc->tulip_system_errors++;
3646 break;
3647 }
3648 if (csr & (TULIP_STS_LINKPASS|TULIP_STS_LINKFAIL) & sc->tulip_intrmask) {
3649 #if defined(TULIP_DEBUG)
3650 sc->tulip_dbg.dbg_link_intrs++;
3651 #endif
3652 if (sc->tulip_boardsw->bd_media_poll != NULL) {
3653 (*sc->tulip_boardsw->bd_media_poll)(sc, csr & TULIP_STS_LINKFAIL
3654 ? TULIP_MEDIAPOLL_LINKFAIL
3655 : TULIP_MEDIAPOLL_LINKPASS);
3656 csr &= ~TULIP_STS_ABNRMLINTR;
3657 }
3658 tulip_media_print(sc);
3659 }
3660 if (csr & (TULIP_STS_RXINTR|TULIP_STS_RXNOBUF)) {
3661 u_int32_t misses = TULIP_CSR_READ(sc, csr_missed_frames);
3662 if (csr & TULIP_STS_RXNOBUF)
3663 sc->tulip_dot3stats.dot3StatsMissedFrames += misses & 0xFFFF;
3664
3665
3666
3667
3668 if ((misses & 0x0FFE0000) && (sc->tulip_features & TULIP_HAVE_RXBADOVRFLW)) {
3669 sc->tulip_dot3stats.dot3StatsInternalMacReceiveErrors++;
3670
3671
3672
3673
3674 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode & ~TULIP_CMD_RXRUN);
3675 while ((TULIP_CSR_READ(sc, csr_status) & TULIP_STS_RXSTOPPED) == 0)
3676 ;
3677 TULIP_CSR_WRITE(sc, csr_status, TULIP_STS_RXSTOPPED);
3678 sc->tulip_flags |= TULIP_RXIGNORE;
3679 }
3680 tulip_rx_intr(sc);
3681 if (sc->tulip_flags & TULIP_RXIGNORE) {
3682
3683
3684
3685 sc->tulip_flags &= ~TULIP_RXIGNORE;
3686 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
3687 }
3688 }
3689 if (csr & TULIP_STS_ABNRMLINTR) {
3690 u_int32_t tmp = csr & sc->tulip_intrmask
3691 & ~(TULIP_STS_NORMALINTR|TULIP_STS_ABNRMLINTR);
3692 if (csr & TULIP_STS_TXUNDERFLOW) {
3693 #if defined(TULIP_DEBUG)
3694 printf ("Underflow interrupt\n");
3695 #endif
3696 if ((sc->tulip_cmdmode & TULIP_CMD_THRESHOLDCTL) != TULIP_CMD_THRSHLD160) {
3697 sc->tulip_cmdmode += TULIP_CMD_THRSHLD96;
3698 sc->tulip_flags |= TULIP_NEWTXTHRESH;
3699 } else if (sc->tulip_features & TULIP_HAVE_STOREFWD) {
3700 sc->tulip_cmdmode |= TULIP_CMD_STOREFWD;
3701 sc->tulip_flags |= TULIP_NEWTXTHRESH;
3702 }
3703 }
3704 if (sc->tulip_flags & TULIP_NOMESSAGES)
3705 sc->tulip_statusbits |= tmp;
3706 else {
3707 tulip_print_abnormal_interrupt(sc, tmp);
3708 sc->tulip_flags |= TULIP_NOMESSAGES;
3709 }
3710 TULIP_CSR_WRITE(sc, csr_command, sc->tulip_cmdmode);
3711 }
3712 if (sc->tulip_flags & (TULIP_WANTTXSTART|TULIP_TXPROBE_ACTIVE|TULIP_DOINGSETUP|TULIP_PROMISC)) {
3713 tulip_tx_intr(sc);
3714 if ((sc->tulip_flags & TULIP_TXPROBE_ACTIVE) == 0)
3715 tulip_ifstart(&sc->tulip_if);
3716 }
3717 }
3718 if (sc->tulip_flags & TULIP_NEEDRESET) {
3719 tulip_reset(sc);
3720 tulip_init(sc);
3721 }
3722 TULIP_PERFEND(intr);
3723 }
3724
3725 int
3726 tulip_intr_shared(void *arg)
3727 {
3728 tulip_softc_t * sc = arg;
3729 int progress = 0;
3730
3731 for (; sc != NULL; sc = sc->tulip_slaves) {
3732 #if defined(TULIP_DEBUG)
3733 sc->tulip_dbg.dbg_intrs++;
3734 #endif
3735 tulip_intr_handler(sc, &progress);
3736 }
3737 return (progress);
3738 }
3739
3740 int
3741 tulip_intr_normal(void *arg)
3742 {
3743 tulip_softc_t * sc = (tulip_softc_t *) arg;
3744 int progress = 0;
3745
3746 #if defined(TULIP_DEBUG)
3747 sc->tulip_dbg.dbg_intrs++;
3748 #endif
3749 tulip_intr_handler(sc, &progress);
3750
3751 return (progress);
3752 }
3753
3754 struct mbuf *
3755 tulip_mbuf_compress(struct mbuf *m)
3756 {
3757 struct mbuf *m0;
3758 #if MCLBYTES >= ETHERMTU + 18
3759 MGETHDR(m0, M_DONTWAIT, MT_DATA);
3760 if (m0 != NULL) {
3761 if (m->m_pkthdr.len > MHLEN) {
3762 MCLGET(m0, M_DONTWAIT);
3763 if ((m0->m_flags & M_EXT) == 0) {
3764 m_freem(m);
3765 m_freem(m0);
3766 return (NULL);
3767 }
3768 }
3769 m_copydata(m, 0, m->m_pkthdr.len, mtod(m0, caddr_t));
3770 m0->m_pkthdr.len = m0->m_len = m->m_pkthdr.len;
3771 }
3772 #else
3773 int mlen = MHLEN;
3774 int len = m->m_pkthdr.len;
3775 struct mbuf **mp = &m0;
3776
3777 while (len > 0) {
3778 if (mlen == MHLEN)
3779 MGETHDR(*mp, M_DONTWAIT, MT_DATA);
3780 else
3781 MGET(*mp, M_DONTWAIT, MT_DATA);
3782 if (*mp == NULL) {
3783 m_freem(m0);
3784 m0 = NULL;
3785 break;
3786 }
3787 if (len > MLEN) {
3788 MCLGET(*mp, M_DONTWAIT);
3789 if (((*mp)->m_flags & M_EXT) == 0) {
3790 m_freem(m0);
3791 m0 = NULL;
3792 break;
3793 }
3794 (*mp)->m_len = len <= MCLBYTES ? len : MCLBYTES;
3795 else
3796 (*mp)->m_len = len <= mlen ? len : mlen;
3797 m_copydata(m, m->m_pkthdr.len - len,
3798 (*mp)->m_len, mtod((*mp), caddr_t));
3799 len -= (*mp)->m_len;
3800 mp = &(*mp)->m_next;
3801 mlen = MLEN;
3802 }
3803 #endif
3804 m_freem(m);
3805 return (m0);
3806 }
3807
3808 struct mbuf *
3809 tulip_txput(tulip_softc_t * const sc, struct mbuf *m)
3810 {
3811 TULIP_PERFSTART(txput)
3812 tulip_ringinfo_t * const ri = &sc->tulip_txinfo;
3813 tulip_desc_t *eop, *nextout;
3814 int segcnt, freedescs;
3815 u_int32_t d_status;
3816 bus_dmamap_t map;
3817 int error;
3818 struct ifnet *ifp = &sc->tulip_if;
3819 struct mbuf *ombuf = m;
3820 int compressed = 0;
3821
3822 #if defined(TULIP_DEBUG)
3823 if ((sc->tulip_cmdmode & TULIP_CMD_TXRUN) == 0) {
3824 printf(TULIP_PRINTF_FMT ": txput%s: tx not running\n",
3825 TULIP_PRINTF_ARGS,
3826 (sc->tulip_flags & TULIP_TXPROBE_ACTIVE) ? "(probe)" : "");
3827 sc->tulip_flags |= TULIP_WANTTXSTART;
3828 sc->tulip_dbg.dbg_txput_finishes[0]++;
3829 goto finish;
3830 }
3831 #endif
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850 d_status = 0;
3851 eop = nextout = ri->ri_nextout;
3852 segcnt = 0;
3853 freedescs = ri->ri_free;
3854
3855
3856
3857
3858 if (sc->tulip_txmaps_free == 0) {
3859 #if defined(TULIP_DEBUG)
3860 sc->tulip_dbg.dbg_no_txmaps++;
3861 #endif
3862 freedescs += tulip_tx_intr(sc);
3863 }
3864 if (sc->tulip_txmaps_free > 0)
3865 map = sc->tulip_txmaps[sc->tulip_txmaps_free-1];
3866 else {
3867 sc->tulip_flags |= TULIP_WANTTXSTART;
3868 #if defined(TULIP_DEBUG)
3869 sc->tulip_dbg.dbg_txput_finishes[1]++;
3870 #endif
3871 goto finish;
3872 }
3873 error = bus_dmamap_load_mbuf(sc->tulip_dmatag, map, m, BUS_DMA_NOWAIT);
3874 if (error != 0) {
3875 if (error == EFBIG) {
3876
3877
3878
3879
3880
3881 struct mbuf *tmp;
3882
3883
3884
3885
3886
3887
3888
3889
3890 if (compressed) {
3891
3892 #ifdef TULIP_DEBUG
3893 printf("tulip_txput: compress called twice!\n");
3894 #endif
3895 goto finish;
3896 }
3897 IFQ_DEQUEUE(&ifp->if_snd, tmp);
3898 if (tmp != ombuf)
3899 panic("tulip_txput: different mbuf dequeued!");
3900 compressed = 1;
3901 m = tulip_mbuf_compress(m);
3902 if (m == NULL) {
3903 #if defined(TULIP_DEBUG)
3904 sc->tulip_dbg.dbg_txput_finishes[2]++;
3905 #endif
3906 goto finish;
3907 }
3908 error = bus_dmamap_load_mbuf(sc->tulip_dmatag, map, m, BUS_DMA_NOWAIT);
3909 }
3910 if (error != 0) {
3911 printf(TULIP_PRINTF_FMT ": unable to load tx map, "
3912 "error = %d\n", TULIP_PRINTF_ARGS, error);
3913 #if defined(TULIP_DEBUG)
3914 sc->tulip_dbg.dbg_txput_finishes[3]++;
3915 #endif
3916 goto finish;
3917 }
3918 }
3919 if ((freedescs -= (map->dm_nsegs + 1) / 2) <= 0
3920
3921
3922
3923 && (freedescs += tulip_tx_intr(sc)) <= 0) {
3924
3925
3926
3927
3928
3929
3930 sc->tulip_flags |= TULIP_WANTTXSTART;
3931 #if defined(TULIP_DEBUG)
3932 sc->tulip_dbg.dbg_txput_finishes[4]++;
3933 #endif
3934 bus_dmamap_unload(sc->tulip_dmatag, map);
3935 goto finish;
3936 }
3937 for (; map->dm_nsegs - segcnt > 1; segcnt += 2) {
3938 eop = nextout;
3939 eop->d_flag &= TULIP_DFLAG_ENDRING|TULIP_DFLAG_CHAIN;
3940 eop->d_status = d_status;
3941 eop->d_addr1 = map->dm_segs[segcnt].ds_addr;
3942 eop->d_length1 = map->dm_segs[segcnt].ds_len;
3943 eop->d_addr2 = map->dm_segs[segcnt+1].ds_addr;
3944 eop->d_length2 = map->dm_segs[segcnt+1].ds_len;
3945 d_status = TULIP_DSTS_OWNER;
3946 if (++nextout == ri->ri_last)
3947 nextout = ri->ri_first;
3948 }
3949 if (segcnt < map->dm_nsegs) {
3950 eop = nextout;
3951 eop->d_flag &= TULIP_DFLAG_ENDRING|TULIP_DFLAG_CHAIN;
3952 eop->d_status = d_status;
3953 eop->d_addr1 = map->dm_segs[segcnt].ds_addr;
3954 eop->d_length1 = map->dm_segs[segcnt].ds_len;
3955 eop->d_addr2 = 0;
3956 eop->d_length2 = 0;
3957 if (++nextout == ri->ri_last)
3958 nextout = ri->ri_first;
3959 }
3960 TULIP_TXMAP_PRESYNC(sc, map);
3961 TULIP_SETCTX(m, map);
3962 map = NULL;
3963 --sc->tulip_txmaps_free;
3964
3965
3966
3967
3968
3969 if (!compressed && (sc->tulip_flags & TULIP_TXPROBE_ACTIVE) == 0) {
3970
3971 struct mbuf *tmp;
3972 IFQ_DEQUEUE(&ifp->if_snd, tmp);
3973 if (tmp != ombuf)
3974 panic("tulip_txput: different mbuf dequeued!");
3975 }
3976
3977 IF_ENQUEUE(&sc->tulip_txq, m);
3978 m = NULL;
3979
3980
3981
3982
3983
3984
3985 nextout->d_status = 0;
3986 TULIP_TXDESC_PRESYNC(sc, nextout, sizeof(u_int32_t));
3987
3988
3989
3990
3991
3992 eop->d_flag |= TULIP_DFLAG_TxLASTSEG|TULIP_DFLAG_TxWANTINTR;
3993
3994
3995
3996
3997
3998
3999 ri->ri_nextout->d_flag |= TULIP_DFLAG_TxFIRSTSEG;
4000 if (eop < ri->ri_nextout) {
4001 TULIP_TXDESC_PRESYNC(sc, ri->ri_nextout,
4002 (caddr_t) ri->ri_last - (caddr_t) ri->ri_nextout);
4003 TULIP_TXDESC_PRESYNC(sc, ri->ri_first,
4004 (caddr_t) (eop + 1) - (caddr_t) ri->ri_first);
4005 } else {
4006 TULIP_TXDESC_PRESYNC(sc, ri->ri_nextout,
4007 (caddr_t) (eop + 1) - (caddr_t) ri->ri_nextout);
4008 }
4009 ri->ri_nextout->d_status = TULIP_DSTS_OWNER;
4010 TULIP_TXDESC_PRESYNC(sc, ri->ri_nextout, sizeof(u_int32_t));
4011
4012
4013
4014
4015 ri->ri_nextout = nextout;
4016 ri->ri_free = freedescs;
4017
4018 TULIP_PERFEND(txput);
4019
4020 if (sc->tulip_flags & TULIP_TXPROBE_ACTIVE) {
4021 TULIP_CSR_WRITE(sc, csr_txpoll, 1);
4022 sc->tulip_if.if_flags |= IFF_OACTIVE;
4023 sc->tulip_if.if_start = tulip_ifstart;
4024 TULIP_PERFEND(txput);
4025 return (NULL);
4026 }
4027
4028
4029
4030
4031 sc->tulip_flags &= ~TULIP_WANTTXSTART;
4032 if (sc->tulip_txtimer == 0)
4033 sc->tulip_txtimer = TULIP_TXTIMER;
4034 #if defined(TULIP_DEBUG)
4035 sc->tulip_dbg.dbg_txput_finishes[5]++;
4036 #endif
4037
4038
4039
4040
4041
4042
4043
4044
4045
4046
4047 finish:
4048 #if defined(TULIP_DEBUG)
4049 sc->tulip_dbg.dbg_txput_finishes[6]++;
4050 #endif
4051 if (sc->tulip_flags & (TULIP_WANTTXSTART|TULIP_DOINGSETUP)) {
4052 sc->tulip_if.if_flags |= IFF_OACTIVE;
4053 sc->tulip_if.if_start = tulip_ifstart;
4054 if ((sc->tulip_intrmask & TULIP_STS_TXINTR) == 0) {
4055 sc->tulip_intrmask |= TULIP_STS_TXINTR;
4056 TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
4057 }
4058 } else if ((sc->tulip_flags & TULIP_PROMISC) == 0) {
4059 if (sc->tulip_intrmask & TULIP_STS_TXINTR) {
4060 sc->tulip_intrmask &= ~TULIP_STS_TXINTR;
4061 TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
4062 }
4063 }
4064 TULIP_CSR_WRITE(sc, csr_txpoll, 1);
4065 TULIP_PERFEND(txput);
4066 return (m);
4067 }
4068
4069 void
4070 tulip_txput_setup(tulip_softc_t * const sc)
4071 {
4072 tulip_ringinfo_t * const ri = &sc->tulip_txinfo;
4073 tulip_desc_t *nextout;
4074
4075
4076
4077
4078
4079 #if defined(TULIP_DEBUG)
4080 if ((sc->tulip_cmdmode & TULIP_CMD_TXRUN) == 0) {
4081 printf(TULIP_PRINTF_FMT ": txput_setup: tx not running\n",
4082 TULIP_PRINTF_ARGS);
4083 sc->tulip_flags |= TULIP_WANTTXSTART;
4084 sc->tulip_if.if_start = tulip_ifstart;
4085 return;
4086 }
4087 #endif
4088
4089
4090
4091 if (ri->ri_free < 2)
4092 tulip_tx_intr(sc);
4093 if ((sc->tulip_flags & TULIP_DOINGSETUP) || ri->ri_free == 1) {
4094 sc->tulip_flags |= TULIP_WANTTXSTART;
4095 sc->tulip_if.if_start = tulip_ifstart;
4096 return;
4097 }
4098 bcopy(sc->tulip_setupdata, sc->tulip_setupbuf,
4099 sizeof(sc->tulip_setupbuf));
4100
4101
4102
4103
4104 sc->tulip_flags ^= TULIP_WANTSETUP|TULIP_DOINGSETUP;
4105 ri->ri_free--;
4106 nextout = ri->ri_nextout;
4107 nextout->d_flag &= TULIP_DFLAG_ENDRING|TULIP_DFLAG_CHAIN;
4108 nextout->d_flag |= TULIP_DFLAG_TxFIRSTSEG|TULIP_DFLAG_TxLASTSEG
4109 |TULIP_DFLAG_TxSETUPPKT|TULIP_DFLAG_TxWANTINTR;
4110 if (sc->tulip_flags & TULIP_WANTHASHPERFECT)
4111 nextout->d_flag |= TULIP_DFLAG_TxHASHFILT;
4112 else if (sc->tulip_flags & TULIP_WANTHASHONLY)
4113 nextout->d_flag |= TULIP_DFLAG_TxHASHFILT|TULIP_DFLAG_TxINVRSFILT;
4114
4115 nextout->d_length2 = 0;
4116 nextout->d_addr2 = 0;
4117 nextout->d_length1 = sc->tulip_setupmap->dm_segs[0].ds_len;
4118 nextout->d_addr1 = sc->tulip_setupmap->dm_segs[0].ds_addr;
4119 if (sc->tulip_setupmap->dm_nsegs == 2) {
4120 nextout->d_length2 = sc->tulip_setupmap->dm_segs[1].ds_len;
4121 nextout->d_addr2 = sc->tulip_setupmap->dm_segs[1].ds_addr;
4122 }
4123 TULIP_TXMAP_PRESYNC(sc, sc->tulip_setupmap);
4124 TULIP_TXDESC_PRESYNC(sc, nextout, sizeof(*nextout));
4125
4126
4127
4128
4129 if (++ri->ri_nextout == ri->ri_last)
4130 ri->ri_nextout = ri->ri_first;
4131
4132
4133
4134
4135
4136
4137 ri->ri_nextout->d_status = 0;
4138 TULIP_TXDESC_PRESYNC(sc, ri->ri_nextout, sizeof(u_int32_t));
4139 nextout->d_status = TULIP_DSTS_OWNER;
4140
4141
4142
4143 TULIP_TXDESC_PRESYNC(sc, nextout, sizeof(u_int32_t));
4144 TULIP_CSR_WRITE(sc, csr_txpoll, 1);
4145 if ((sc->tulip_intrmask & TULIP_STS_TXINTR) == 0) {
4146 sc->tulip_intrmask |= TULIP_STS_TXINTR;
4147 TULIP_CSR_WRITE(sc, csr_intr, sc->tulip_intrmask);
4148 }
4149 }
4150
4151
4152
4153
4154 int
4155 tulip_ifioctl(struct ifnet * ifp, u_long cmd, caddr_t data)
4156 {
4157 TULIP_PERFSTART(ifioctl)
4158 tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
4159 struct ifaddr *ifa = (struct ifaddr *)data;
4160 struct ifreq *ifr = (struct ifreq *) data;
4161 int s;
4162 int error = 0;
4163
4164 s = splnet();
4165
4166 if ((error = ether_ioctl(ifp, &sc->tulip_ac, cmd, data)) > 0) {
4167 splx(s);
4168 return (error);
4169 }
4170
4171 switch (cmd) {
4172 case SIOCSIFADDR: {
4173 ifp->if_flags |= IFF_UP;
4174 tulip_init(sc);
4175 switch(ifa->ifa_addr->sa_family) {
4176 #ifdef INET
4177 case AF_INET: {
4178 arp_ifinit(&sc->tulip_ac, ifa);
4179 break;
4180 }
4181 #endif
4182
4183 default: {
4184 break;
4185 }
4186 }
4187 break;
4188 }
4189
4190 case SIOCSIFFLAGS: {
4191 tulip_init(sc);
4192 break;
4193 }
4194
4195 case SIOCSIFMEDIA:
4196 case SIOCGIFMEDIA: {
4197 error = ifmedia_ioctl(ifp, ifr, &sc->tulip_ifmedia, cmd);
4198 break;
4199 }
4200
4201 case SIOCADDMULTI:
4202 case SIOCDELMULTI: {
4203
4204
4205
4206 if (cmd == SIOCADDMULTI)
4207 error = ether_addmulti(ifr, &sc->tulip_ac);
4208 else
4209 error = ether_delmulti(ifr, &sc->tulip_ac);
4210
4211 if (error == ENETRESET) {
4212 if (ifp->if_flags & IFF_RUNNING) {
4213 tulip_addr_filter(sc);
4214 tulip_init(sc);
4215 }
4216 error = 0;
4217 }
4218 break;
4219 }
4220
4221 case SIOCSIFMTU:
4222
4223
4224
4225 if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > ETHERMTU)
4226 error = EINVAL;
4227 else if (ifp->if_mtu != ifr->ifr_mtu)
4228 ifp->if_mtu = ifr->ifr_mtu;
4229 break;
4230
4231 default:
4232 error = ENOTTY;
4233 break;
4234 }
4235
4236 splx(s);
4237 TULIP_PERFEND(ifioctl);
4238 return (error);
4239 }
4240
4241
4242
4243
4244
4245
4246
4247
4248
4249
4250
4251 void
4252 tulip_ifstart(struct ifnet * const ifp)
4253 {
4254 TULIP_PERFSTART(ifstart)
4255 tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
4256
4257 if (sc->tulip_if.if_flags & IFF_RUNNING) {
4258
4259 if ((sc->tulip_flags & (TULIP_WANTSETUP|TULIP_TXPROBE_ACTIVE)) == TULIP_WANTSETUP)
4260 tulip_txput_setup(sc);
4261
4262 while (!IFQ_IS_EMPTY(&sc->tulip_if.if_snd)) {
4263 struct mbuf *m, *m0;
4264 IFQ_POLL(&sc->tulip_if.if_snd, m);
4265 if (m == NULL)
4266 break;
4267 if ((m0 = tulip_txput(sc, m)) != NULL) {
4268 if (m0 != m)
4269
4270 printf("tulip_if_start: txput failed!\n");
4271 break;
4272 }
4273 }
4274 #ifdef ALTQ
4275 if (0)
4276 #else
4277 if (IFQ_IS_EMPTY(&sc->tulip_if.if_snd))
4278 #endif
4279 sc->tulip_if.if_start = tulip_ifstart_one;
4280 }
4281
4282 TULIP_PERFEND(ifstart);
4283 }
4284
4285 void
4286 tulip_ifstart_one(struct ifnet * const ifp)
4287 {
4288 TULIP_PERFSTART(ifstart_one)
4289 tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
4290
4291 if ((sc->tulip_if.if_flags & IFF_RUNNING)
4292 && !IFQ_IS_EMPTY(&sc->tulip_if.if_snd)) {
4293 struct mbuf *m, *m0;
4294 IFQ_POLL(&sc->tulip_if.if_snd, m);
4295 if (m != NULL && (m0 = tulip_txput(sc, m)) != NULL)
4296 if (m0 != m)
4297
4298 printf("tulip_if_start_one: txput failed!\n");
4299 }
4300 TULIP_PERFEND(ifstart_one);
4301 }
4302
4303 void
4304 tulip_ifwatchdog(struct ifnet *ifp)
4305 {
4306 TULIP_PERFSTART(ifwatchdog)
4307 tulip_softc_t * const sc = TULIP_IFP_TO_SOFTC(ifp);
4308
4309 #if defined(TULIP_DEBUG)
4310 u_int32_t rxintrs = sc->tulip_dbg.dbg_rxintrs - sc->tulip_dbg.dbg_last_rxintrs;
4311 if (rxintrs > sc->tulip_dbg.dbg_high_rxintrs_hz)
4312 sc->tulip_dbg.dbg_high_rxintrs_hz = rxintrs;
4313 sc->tulip_dbg.dbg_last_rxintrs = sc->tulip_dbg.dbg_rxintrs;
4314 #endif
4315
4316 sc->tulip_if.if_timer = 1;
4317
4318
4319
4320
4321 if (sc->tulip_flags & (TULIP_SYSTEMERROR|TULIP_RXBUFSLOW|TULIP_NOMESSAGES)) {
4322
4323
4324
4325 if (sc->tulip_flags & TULIP_RXBUFSLOW)
4326 tulip_rx_intr(sc);
4327
4328 #if defined(TULIP_DEBUG)
4329 if (sc->tulip_flags & TULIP_SYSTEMERROR) {
4330 printf(TULIP_PRINTF_FMT ": %d system errors: last was %s\n",
4331 TULIP_PRINTF_ARGS, sc->tulip_system_errors,
4332 tulip_system_errors[sc->tulip_last_system_error]);
4333 }
4334 #endif
4335 if (sc->tulip_statusbits) {
4336 tulip_print_abnormal_interrupt(sc, sc->tulip_statusbits);
4337 sc->tulip_statusbits = 0;
4338 }
4339
4340 sc->tulip_flags &= ~(TULIP_NOMESSAGES|TULIP_SYSTEMERROR);
4341 }
4342
4343 if (sc->tulip_txtimer)
4344 tulip_tx_intr(sc);
4345 if (sc->tulip_txtimer && --sc->tulip_txtimer == 0) {
4346 printf(TULIP_PRINTF_FMT ": transmission timeout\n", TULIP_PRINTF_ARGS);
4347 if (TULIP_DO_AUTOSENSE(sc)) {
4348 sc->tulip_media = TULIP_MEDIA_UNKNOWN;
4349 sc->tulip_probe_state = TULIP_PROBE_INACTIVE;
4350 sc->tulip_flags &= ~(TULIP_WANTRXACT|TULIP_LINKUP);
4351 }
4352 tulip_reset(sc);
4353 tulip_init(sc);
4354 }
4355
4356 TULIP_PERFEND(ifwatchdog);
4357 TULIP_PERFMERGE(sc, perf_intr_cycles);
4358 TULIP_PERFMERGE(sc, perf_ifstart_cycles);
4359 TULIP_PERFMERGE(sc, perf_ifioctl_cycles);
4360 TULIP_PERFMERGE(sc, perf_ifwatchdog_cycles);
4361 TULIP_PERFMERGE(sc, perf_timeout_cycles);
4362 TULIP_PERFMERGE(sc, perf_ifstart_one_cycles);
4363 TULIP_PERFMERGE(sc, perf_txput_cycles);
4364 TULIP_PERFMERGE(sc, perf_txintr_cycles);
4365 TULIP_PERFMERGE(sc, perf_rxintr_cycles);
4366 TULIP_PERFMERGE(sc, perf_rxget_cycles);
4367 TULIP_PERFMERGE(sc, perf_intr);
4368 TULIP_PERFMERGE(sc, perf_ifstart);
4369 TULIP_PERFMERGE(sc, perf_ifioctl);
4370 TULIP_PERFMERGE(sc, perf_ifwatchdog);
4371 TULIP_PERFMERGE(sc, perf_timeout);
4372 TULIP_PERFMERGE(sc, perf_ifstart_one);
4373 TULIP_PERFMERGE(sc, perf_txput);
4374 TULIP_PERFMERGE(sc, perf_txintr);
4375 TULIP_PERFMERGE(sc, perf_rxintr);
4376 TULIP_PERFMERGE(sc, perf_rxget);
4377 }
4378
4379
4380
4381
4382 #ifdef printf
4383 #undef printf
4384 #endif
4385
4386 int
4387 tulip_busdma_allocmem(tulip_softc_t * const sc, size_t size,
4388 bus_dmamap_t *map_p, tulip_desc_t **desc_p)
4389 {
4390 bus_dma_segment_t segs[1];
4391 int nsegs, error;
4392 error = bus_dmamem_alloc(sc->tulip_dmatag, size, 1, PAGE_SIZE,
4393 segs, sizeof(segs)/sizeof(segs[0]),
4394 &nsegs, BUS_DMA_NOWAIT);
4395 if (error == 0) {
4396 void *desc;
4397 error = bus_dmamem_map(sc->tulip_dmatag, segs, nsegs, size,
4398 (void *) &desc, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
4399 if (error == 0) {
4400 bus_dmamap_t map;
4401 error = bus_dmamap_create(sc->tulip_dmatag, size, 1, size, 0,
4402 BUS_DMA_NOWAIT, &map);
4403 if (error == 0) {
4404 error = bus_dmamap_load(sc->tulip_dmatag, map, desc,
4405 size, NULL, BUS_DMA_NOWAIT);
4406 if (error)
4407 bus_dmamap_destroy(sc->tulip_dmatag, map);
4408 else
4409 *map_p = map;
4410 }
4411 if (error)
4412 bus_dmamem_unmap(sc->tulip_dmatag, desc, size);
4413 }
4414 if (error)
4415 bus_dmamem_free(sc->tulip_dmatag, segs, nsegs);
4416 else
4417 *desc_p = desc;
4418 }
4419 return (error);
4420 }
4421
4422 int
4423 tulip_busdma_init(tulip_softc_t * const sc)
4424 {
4425 int error = 0;
4426
4427
4428
4429
4430 error = bus_dmamap_create(sc->tulip_dmatag, sizeof(sc->tulip_setupbuf), 2,
4431 sizeof(sc->tulip_setupbuf), 0, BUS_DMA_NOWAIT,
4432 &sc->tulip_setupmap);
4433 if (error == 0) {
4434 error = bus_dmamap_load(sc->tulip_dmatag, sc->tulip_setupmap,
4435 sc->tulip_setupbuf, sizeof(sc->tulip_setupbuf),
4436 NULL, BUS_DMA_NOWAIT);
4437 if (error)
4438 bus_dmamap_destroy(sc->tulip_dmatag, sc->tulip_setupmap);
4439 }
4440
4441
4442
4443 if (error == 0) {
4444 error = tulip_busdma_allocmem(sc, sizeof(tulip_desc_t) * TULIP_TXDESCS,
4445 &sc->tulip_txdescmap,
4446 &sc->tulip_txdescs);
4447 }
4448
4449
4450
4451
4452 if (error == 0) {
4453 while (error == 0 && sc->tulip_txmaps_free < TULIP_TXDESCS) {
4454 bus_dmamap_t map;
4455 if ((error = TULIP_TXMAP_CREATE(sc, &map)) == 0)
4456 sc->tulip_txmaps[sc->tulip_txmaps_free++] = map;
4457 }
4458 if (error) {
4459 while (sc->tulip_txmaps_free > 0)
4460 bus_dmamap_destroy(sc->tulip_dmatag,
4461 sc->tulip_txmaps[--sc->tulip_txmaps_free]);
4462 }
4463 }
4464
4465
4466
4467
4468 if (error == 0) {
4469 error = tulip_busdma_allocmem(sc, sizeof(tulip_desc_t) * TULIP_RXDESCS,
4470 &sc->tulip_rxdescmap,
4471 &sc->tulip_rxdescs);
4472 }
4473
4474
4475
4476
4477 if (error == 0) {
4478 while (error == 0 && sc->tulip_rxmaps_free < TULIP_RXDESCS) {
4479 bus_dmamap_t map;
4480 if ((error = TULIP_RXMAP_CREATE(sc, &map)) == 0)
4481 sc->tulip_rxmaps[sc->tulip_rxmaps_free++] = map;
4482 }
4483 if (error) {
4484 while (sc->tulip_rxmaps_free > 0)
4485 bus_dmamap_destroy(sc->tulip_dmatag,
4486 sc->tulip_rxmaps[--sc->tulip_rxmaps_free]);
4487 }
4488 }
4489 return (error);
4490 }
4491
4492 void
4493 tulip_initcsrs(tulip_softc_t * const sc, bus_addr_t csr_base, size_t csr_size)
4494 {
4495 sc->tulip_csrs.csr_busmode = csr_base + 0 * csr_size;
4496 sc->tulip_csrs.csr_txpoll = csr_base + 1 * csr_size;
4497 sc->tulip_csrs.csr_rxpoll = csr_base + 2 * csr_size;
4498 sc->tulip_csrs.csr_rxlist = csr_base + 3 * csr_size;
4499 sc->tulip_csrs.csr_txlist = csr_base + 4 * csr_size;
4500 sc->tulip_csrs.csr_status = csr_base + 5 * csr_size;
4501 sc->tulip_csrs.csr_command = csr_base + 6 * csr_size;
4502 sc->tulip_csrs.csr_intr = csr_base + 7 * csr_size;
4503 sc->tulip_csrs.csr_missed_frames = csr_base + 8 * csr_size;
4504 sc->tulip_csrs.csr_9 = csr_base + 9 * csr_size;
4505 sc->tulip_csrs.csr_10 = csr_base + 10 * csr_size;
4506 sc->tulip_csrs.csr_11 = csr_base + 11 * csr_size;
4507 sc->tulip_csrs.csr_12 = csr_base + 12 * csr_size;
4508 sc->tulip_csrs.csr_13 = csr_base + 13 * csr_size;
4509 sc->tulip_csrs.csr_14 = csr_base + 14 * csr_size;
4510 sc->tulip_csrs.csr_15 = csr_base + 15 * csr_size;
4511 }
4512
4513 void
4514 tulip_initring(tulip_softc_t * const sc, tulip_ringinfo_t * const ri,
4515 tulip_desc_t *descs, int ndescs)
4516 {
4517 ri->ri_max = ndescs;
4518 ri->ri_first = descs;
4519 ri->ri_last = ri->ri_first + ri->ri_max;
4520 bzero((caddr_t) ri->ri_first, sizeof(ri->ri_first[0]) * ri->ri_max);
4521 ri->ri_last[-1].d_flag = TULIP_DFLAG_ENDRING;
4522 }
4523
4524 int
4525 tulip_probe(struct device *parent, void *match, void *aux)
4526 {
4527 struct pci_attach_args *pa = (struct pci_attach_args *) aux;
4528
4529 if (PCI_VENDORID(pa->pa_id) != DEC_VENDORID)
4530 return (0);
4531 if (PCI_CHIPID(pa->pa_id) == CHIPID_21040
4532 || PCI_CHIPID(pa->pa_id) == CHIPID_21041
4533 || PCI_CHIPID(pa->pa_id) == CHIPID_21140
4534 || PCI_CHIPID(pa->pa_id) == CHIPID_21142)
4535 return (2);
4536
4537 return (0);
4538 }
4539
4540 void
4541 tulip_shutdown(void *arg)
4542 {
4543 tulip_softc_t * const sc = arg;
4544 TULIP_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
4545 DELAY(10);
4546
4547
4548 }
4549
4550 void
4551 tulip_attach(struct device * const parent, struct device * const self, void * const aux)
4552 {
4553 tulip_softc_t * const sc = (tulip_softc_t *) self;
4554 struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
4555 struct ifnet * const ifp = &sc->tulip_if;
4556 const int unit = sc->tulip_dev.dv_unit;
4557 int retval, idx;
4558 u_int32_t revinfo, cfdainfo, id;
4559 unsigned csroffset = TULIP_PCI_CSROFFSET;
4560 unsigned csrsize = TULIP_PCI_CSRSIZE;
4561 bus_addr_t csr_base;
4562 tulip_chipid_t chipid = TULIP_CHIPID_UNKNOWN;
4563
4564 if (unit >= TULIP_MAX_DEVICES) {
4565 printf(": not configured; limit of %d reached or exceeded\n",
4566 TULIP_MAX_DEVICES);
4567 return;
4568 }
4569
4570 revinfo = PCI_CONF_READ(PCI_CFRV) & 0xFF;
4571 id = PCI_CONF_READ(PCI_CFID);
4572 cfdainfo = PCI_CONF_READ(PCI_CFDA);
4573
4574 if (PCI_VENDORID(id) == DEC_VENDORID) {
4575 if (PCI_CHIPID(id) == CHIPID_21040)
4576 chipid = TULIP_21040;
4577 else if (PCI_CHIPID(id) == CHIPID_21041)
4578 chipid = TULIP_21041;
4579 else if (PCI_CHIPID(id) == CHIPID_21140)
4580 chipid = (revinfo >= 0x20) ? TULIP_21140A : TULIP_21140;
4581 else if (PCI_CHIPID(id) == CHIPID_21142)
4582 chipid = (revinfo >= 0x20) ? TULIP_21143 : TULIP_21142;
4583 }
4584
4585 if (chipid == TULIP_CHIPID_UNKNOWN)
4586 return;
4587
4588 if ((chipid == TULIP_21040 || chipid == TULIP_DE425) && revinfo < 0x20) {
4589 printf(": not configured; 21040 pass 2.0 required (%d.%d found)\n",
4590 revinfo >> 4, revinfo & 0x0f);
4591 return;
4592 } else if (chipid == TULIP_21140 && revinfo < 0x11) {
4593 printf(": not configured; 21140 pass 1.1 required (%d.%d found)\n",
4594 revinfo >> 4, revinfo & 0x0f);
4595 return;
4596 }
4597
4598 PCI_GETBUSDEVINFO(sc);
4599 sc->tulip_chipid = chipid;
4600 sc->tulip_flags |= TULIP_DEVICEPROBE;
4601 if (chipid == TULIP_21140 || chipid == TULIP_21140A)
4602 sc->tulip_features |= TULIP_HAVE_GPR|TULIP_HAVE_STOREFWD;
4603 if (chipid == TULIP_21140A && revinfo <= 0x22)
4604 sc->tulip_features |= TULIP_HAVE_RXBADOVRFLW;
4605 if (chipid == TULIP_21140)
4606 sc->tulip_features |= TULIP_HAVE_BROKEN_HASH;
4607 if (chipid != TULIP_21040 && chipid != TULIP_DE425 && chipid != TULIP_21140)
4608 sc->tulip_features |= TULIP_HAVE_POWERMGMT;
4609 if (chipid == TULIP_21041 || chipid == TULIP_21142 || chipid == TULIP_21143) {
4610 sc->tulip_features |= TULIP_HAVE_DUALSENSE;
4611 if (chipid != TULIP_21041 || revinfo >= 0x20)
4612 sc->tulip_features |= TULIP_HAVE_SIANWAY;
4613 if (chipid != TULIP_21041)
4614 sc->tulip_features |= TULIP_HAVE_SIAGP|TULIP_HAVE_RXBADOVRFLW|TULIP_HAVE_STOREFWD;
4615 if (chipid != TULIP_21041 && revinfo >= 0x20)
4616 sc->tulip_features |= TULIP_HAVE_SIA100;
4617 }
4618
4619 if (sc->tulip_features & TULIP_HAVE_POWERMGMT
4620 && (cfdainfo & (TULIP_CFDA_SLEEP|TULIP_CFDA_SNOOZE))) {
4621 cfdainfo &= ~(TULIP_CFDA_SLEEP|TULIP_CFDA_SNOOZE);
4622 PCI_CONF_WRITE(PCI_CFDA, cfdainfo);
4623 DELAY(11*1000);
4624 }
4625
4626 if (sc->tulip_features & TULIP_HAVE_STOREFWD)
4627 sc->tulip_cmdmode |= TULIP_CMD_STOREFWD;
4628
4629 bcopy(self->dv_xname, sc->tulip_if.if_xname, IFNAMSIZ);
4630 sc->tulip_if.if_softc = sc;
4631 sc->tulip_pc = pa->pa_pc;
4632 sc->tulip_dmatag = pa->pa_dmat;
4633 sc->tulip_revinfo = revinfo;
4634
4635 timeout_set(&sc->tulip_stmo, tulip_timeout_callback, sc);
4636
4637 csr_base = 0;
4638 {
4639 bus_space_tag_t iot, memt;
4640 bus_space_handle_t ioh, memh;
4641 int ioh_valid, memh_valid;
4642
4643 ioh_valid = (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0,
4644 &iot, &ioh, NULL, NULL, 0) == 0);
4645 memh_valid = (pci_mapreg_map(pa, PCI_CBMA,
4646 PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT, 0,
4647 &memt, &memh, NULL, NULL, 0) == 0);
4648
4649 if (memh_valid) {
4650 sc->tulip_bustag = memt;
4651 sc->tulip_bushandle = memh;
4652 } else if (ioh_valid) {
4653 sc->tulip_bustag = iot;
4654 sc->tulip_bushandle = ioh;
4655 } else {
4656 printf(": unable to map device registers\n");
4657 return;
4658 }
4659 }
4660
4661 tulip_initcsrs(sc, csr_base + csroffset, csrsize);
4662
4663 if ((retval = tulip_busdma_init(sc)) != 0) {
4664 printf(": error initing bus_dma: %d\n", retval);
4665 return;
4666 }
4667
4668 tulip_initring(sc, &sc->tulip_rxinfo, sc->tulip_rxdescs, TULIP_RXDESCS);
4669 tulip_initring(sc, &sc->tulip_txinfo, sc->tulip_txdescs, TULIP_TXDESCS);
4670
4671
4672
4673
4674 TULIP_CSR_WRITE(sc, csr_busmode, TULIP_BUSMODE_SWRESET);
4675 DELAY(100);
4676
4677
4678
4679 if ((retval = tulip_read_macaddr(sc)) < 0) {
4680 printf(", %s%s pass %d.%d", sc->tulip_boardid,
4681 tulip_chipdescs[sc->tulip_chipid],
4682 (sc->tulip_revinfo & 0xF0) >> 4, sc->tulip_revinfo & 0x0F);
4683 printf(": can't read ENET ROM (why=%d) (", retval);
4684 for (idx = 0; idx < 32; idx++)
4685 printf("%02x", sc->tulip_rombuf[idx]);
4686 printf(", address unknown\n");
4687 } else {
4688 int (*intr_rtn)(void *) = tulip_intr_normal;
4689
4690 if (sc->tulip_features & TULIP_HAVE_SHAREDINTR)
4691 intr_rtn = tulip_intr_shared;
4692
4693 if ((sc->tulip_features & TULIP_HAVE_SLAVEDINTR) == 0) {
4694 pci_intr_handle_t intrhandle;
4695 const char *intrstr;
4696
4697 if (pci_intr_map(pa, &intrhandle)) {
4698 printf(": couldn't map interrupt\n");
4699 return;
4700 }
4701
4702 intrstr = pci_intr_string(pa->pa_pc, intrhandle);
4703 sc->tulip_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET,
4704 intr_rtn, sc, self->dv_xname);
4705 if (sc->tulip_ih == NULL) {
4706 printf(": couldn't establish interrupt");
4707 if (intrstr != NULL)
4708 printf(" at %s", intrstr);
4709 printf("\n");
4710 return;
4711 }
4712
4713 printf(", %s%s pass %d.%d%s: %s, address %s\n",
4714 sc->tulip_boardid,
4715 tulip_chipdescs[sc->tulip_chipid],
4716 (sc->tulip_revinfo & 0xF0) >> 4,
4717 sc->tulip_revinfo & 0x0F,
4718 (sc->tulip_features & (TULIP_HAVE_ISVSROM|TULIP_HAVE_OKSROM))
4719 == TULIP_HAVE_ISVSROM ? " (invalid EESPROM checksum)" : "",
4720 intrstr, ether_sprintf(sc->tulip_enaddr));
4721 }
4722
4723 sc->tulip_ats = shutdownhook_establish(tulip_shutdown, sc);
4724 if (sc->tulip_ats == NULL)
4725 printf("%s: warning: couldn't establish shutdown hook\n",
4726 sc->tulip_xname);
4727
4728 ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_NOTRAILERS|IFF_MULTICAST;
4729 ifp->if_ioctl = tulip_ifioctl;
4730 ifp->if_start = tulip_ifstart;
4731 ifp->if_watchdog = tulip_ifwatchdog;
4732 ifp->if_timer = 1;
4733
4734 (*sc->tulip_boardsw->bd_media_probe)(sc);
4735 ifmedia_init(&sc->tulip_ifmedia, 0,
4736 tulip_ifmedia_change, tulip_ifmedia_status);
4737 sc->tulip_flags &= ~TULIP_DEVICEPROBE;
4738 tulip_ifmedia_add(sc);
4739
4740 tulip_reset(sc);
4741
4742 IFQ_SET_READY(&ifp->if_snd);
4743 if_attach(ifp);
4744 ether_ifattach(ifp);
4745 }
4746 }