if_tl.c revision 1.10 1 1.10 thorpej /* $NetBSD: if_tl.c,v 1.10 1998/05/05 07:17:12 thorpej Exp $ */
2 1.1 bouyer
3 1.1 bouyer /*
4 1.1 bouyer * Copyright (c) 1997 Manuel Bouyer. All rights reserved.
5 1.1 bouyer *
6 1.1 bouyer * Redistribution and use in source and binary forms, with or without
7 1.1 bouyer * modification, are permitted provided that the following conditions
8 1.1 bouyer * are met:
9 1.1 bouyer * 1. Redistributions of source code must retain the above copyright
10 1.1 bouyer * notice, this list of conditions and the following disclaimer.
11 1.1 bouyer * 2. Redistributions in binary form must reproduce the above copyright
12 1.1 bouyer * notice, this list of conditions and the following disclaimer in the
13 1.1 bouyer * documentation and/or other materials provided with the distribution.
14 1.1 bouyer * 3. All advertising materials mentioning features or use of this software
15 1.1 bouyer * must display the following acknowledgement:
16 1.1 bouyer * This product includes software developed by Manuel Bouyer.
17 1.1 bouyer * 4. The name of the author may not be used to endorse or promote products
18 1.1 bouyer * derived from this software without specific prior written permission.
19 1.1 bouyer *
20 1.1 bouyer * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21 1.1 bouyer * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 1.1 bouyer * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 1.1 bouyer * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24 1.1 bouyer * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 1.1 bouyer * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 1.1 bouyer * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 1.1 bouyer * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 1.1 bouyer * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29 1.1 bouyer * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 1.1 bouyer */
31 1.1 bouyer
32 1.1 bouyer /*
33 1.2 bouyer * Texas Instruments ThunderLAN ethernet controller
34 1.1 bouyer * ThunderLAN Programmer's Guide (TI Literature Number SPWU013A)
35 1.1 bouyer * available from www.ti.com
36 1.1 bouyer */
37 1.1 bouyer
38 1.1 bouyer #undef TLDEBUG
39 1.1 bouyer #define TL_PRIV_STATS
40 1.1 bouyer #undef TLDEBUG_RX
41 1.1 bouyer #undef TLDEBUG_TX
42 1.1 bouyer #undef TLDEBUG_ADDR
43 1.1 bouyer
44 1.1 bouyer #include <sys/param.h>
45 1.1 bouyer #include <sys/systm.h>
46 1.1 bouyer #include <sys/mbuf.h>
47 1.1 bouyer #include <sys/protosw.h>
48 1.1 bouyer #include <sys/socket.h>
49 1.1 bouyer #include <sys/ioctl.h>
50 1.1 bouyer #include <sys/errno.h>
51 1.1 bouyer #include <sys/malloc.h>
52 1.1 bouyer #include <sys/kernel.h>
53 1.1 bouyer #include <sys/proc.h> /* only for declaration of wakeup() used by vm.h */
54 1.1 bouyer #include <sys/device.h>
55 1.1 bouyer
56 1.1 bouyer #include <net/if.h>
57 1.1 bouyer #if defined(SIOCSIFMEDIA)
58 1.1 bouyer #include <net/if_media.h>
59 1.1 bouyer #endif
60 1.1 bouyer #include <net/if_types.h>
61 1.1 bouyer #include <net/if_dl.h>
62 1.1 bouyer #include <net/route.h>
63 1.1 bouyer #include <net/netisr.h>
64 1.1 bouyer
65 1.1 bouyer #include "bpfilter.h"
66 1.1 bouyer #if NBPFILTER > 0
67 1.1 bouyer #include <net/bpf.h>
68 1.1 bouyer #include <net/bpfdesc.h>
69 1.1 bouyer #endif
70 1.1 bouyer
71 1.1 bouyer #ifdef INET
72 1.1 bouyer #include <netinet/in.h>
73 1.1 bouyer #include <netinet/in_systm.h>
74 1.1 bouyer #include <netinet/in_var.h>
75 1.1 bouyer #include <netinet/ip.h>
76 1.1 bouyer #endif
77 1.1 bouyer
78 1.1 bouyer #ifdef NS
79 1.1 bouyer #include <netns/ns.h>
80 1.1 bouyer #include <netns/ns_if.h>
81 1.1 bouyer #endif
82 1.1 bouyer
83 1.1 bouyer #include <vm/vm.h>
84 1.1 bouyer #include <vm/vm_param.h>
85 1.1 bouyer #include <vm/vm_kern.h>
86 1.1 bouyer
87 1.1 bouyer #if defined(__NetBSD__)
88 1.1 bouyer #include <net/if_ether.h>
89 1.1 bouyer #if defined(INET)
90 1.1 bouyer #include <netinet/if_inarp.h>
91 1.1 bouyer #endif
92 1.4 thorpej
93 1.1 bouyer #include <machine/bus.h>
94 1.1 bouyer #include <machine/intr.h>
95 1.4 thorpej
96 1.1 bouyer #include <dev/pci/pcireg.h>
97 1.1 bouyer #include <dev/pci/pcivar.h>
98 1.1 bouyer #include <dev/pci/pcidevs.h>
99 1.1 bouyer #include <dev/i2c/i2c_bus.h>
100 1.1 bouyer #include <dev/i2c/i2c_eeprom.h>
101 1.1 bouyer #include <dev/mii/mii_adapter.h>
102 1.1 bouyer #include <dev/mii/mii_adapters_id.h>
103 1.1 bouyer #include <dev/pci/if_tlregs.h>
104 1.1 bouyer #endif /* __NetBSD__ */
105 1.1 bouyer
106 1.1 bouyer /* number of transmit/receive buffers */
107 1.1 bouyer #ifndef TL_NBUF
108 1.1 bouyer #define TL_NBUF 10
109 1.1 bouyer #endif
110 1.1 bouyer
111 1.1 bouyer /* number of seconds the link can be idle */
112 1.1 bouyer #ifndef TL_IDLETIME
113 1.1 bouyer #define TL_IDLETIME 10
114 1.1 bouyer #endif
115 1.1 bouyer
116 1.1 bouyer struct tl_softc {
117 1.1 bouyer struct device sc_dev; /* base device */
118 1.1 bouyer bus_space_tag_t tl_bustag;
119 1.1 bouyer bus_space_handle_t tl_bushandle; /* CSR region handle */
120 1.1 bouyer void* tl_ih;
121 1.1 bouyer struct ethercom tl_ec;
122 1.1 bouyer u_int8_t tl_enaddr[ETHER_ADDR_LEN]; /* hardware adress */
123 1.1 bouyer struct ifmedia tl_ifmedia;
124 1.1 bouyer u_int16_t tl_flags;
125 1.1 bouyer #define TL_IFACT 0x0001 /* chip has interface activity */
126 1.1 bouyer u_int8_t tl_lasttx; /* we were without input this many seconds */
127 1.1 bouyer i2c_adapter_t i2cbus; /* i2c bus, for eeprom */
128 1.1 bouyer mii_data_t mii; /* mii bus */
129 1.1 bouyer struct Rx_list *Rx_list; /* Receive and transmit lists */
130 1.1 bouyer struct Tx_list *Tx_list;
131 1.1 bouyer struct Rx_list *active_Rx, *last_Rx;
132 1.1 bouyer struct Tx_list *active_Tx, *last_Tx;
133 1.1 bouyer struct Tx_list *Free_Tx;
134 1.1 bouyer int opkt; /* used to detect link up/down for AUI/BNC */
135 1.1 bouyer int stats_exesscoll; /* idem */
136 1.1 bouyer #ifdef TL_PRIV_STATS
137 1.1 bouyer int ierr_overr;
138 1.1 bouyer int ierr_code;
139 1.1 bouyer int ierr_crc;
140 1.1 bouyer int ierr_nomem;
141 1.1 bouyer int oerr_underr;
142 1.1 bouyer int oerr_deffered;
143 1.1 bouyer int oerr_coll;
144 1.1 bouyer int oerr_multicoll;
145 1.1 bouyer int oerr_latecoll;
146 1.1 bouyer int oerr_exesscoll;
147 1.1 bouyer int oerr_carrloss;
148 1.1 bouyer int oerr_mcopy;
149 1.1 bouyer #endif
150 1.1 bouyer };
151 1.1 bouyer #define tl_if tl_ec.ec_if
152 1.1 bouyer #define tl_bpf tl_if.if_bpf
153 1.1 bouyer
154 1.1 bouyer typedef struct tl_softc tl_softc_t;
155 1.1 bouyer typedef u_long ioctl_cmd_t;
156 1.1 bouyer
157 1.1 bouyer #define TL_HR_READ(sc, reg) \
158 1.1 bouyer bus_space_read_4(sc->tl_bustag, sc->tl_bushandle, (reg))
159 1.1 bouyer #define TL_HR_READ_BYTE(sc, reg) \
160 1.1 bouyer bus_space_read_1(sc->tl_bustag, sc->tl_bushandle, (reg))
161 1.1 bouyer #define TL_HR_WRITE(sc, reg, data) \
162 1.1 bouyer bus_space_write_4(sc->tl_bustag, sc->tl_bushandle, (reg), (data))
163 1.1 bouyer #define TL_HR_WRITE_BYTE(sc, reg, data) \
164 1.1 bouyer bus_space_write_1(sc->tl_bustag, sc->tl_bushandle, (reg), (data))
165 1.1 bouyer #define ETHER_MIN_TX (ETHERMIN + sizeof(struct ether_header))
166 1.1 bouyer
167 1.7 drochner #ifdef __BROKEN_INDIRECT_CONFIG
168 1.4 thorpej static int tl_pci_match __P((struct device *, void *, void *));
169 1.7 drochner #else
170 1.7 drochner static int tl_pci_match __P((struct device *, struct cfdata *, void *));
171 1.7 drochner #endif
172 1.1 bouyer static void tl_pci_attach __P((struct device *, struct device *, void *));
173 1.1 bouyer static int tl_intr __P((void *));
174 1.1 bouyer
175 1.1 bouyer static int tl_ifioctl __P((struct ifnet *, ioctl_cmd_t, caddr_t));
176 1.1 bouyer static int tl_mediachange __P((struct ifnet *));
177 1.1 bouyer static void tl_mediastatus __P((struct ifnet *, struct ifmediareq *));
178 1.1 bouyer static void tl_ifwatchdog __P((struct ifnet *));
179 1.1 bouyer static void tl_shutdown __P((void*));
180 1.1 bouyer
181 1.1 bouyer static void tl_ifstart __P((struct ifnet *));
182 1.1 bouyer static void tl_reset __P((tl_softc_t*));
183 1.1 bouyer static int tl_init __P((tl_softc_t*));
184 1.1 bouyer static void tl_restart __P((void *));
185 1.1 bouyer static int tl_add_RxBuff __P((struct Rx_list*, struct mbuf*));
186 1.1 bouyer static void tl_read_stats __P((tl_softc_t*));
187 1.1 bouyer static void tl_ticks __P((void*));
188 1.1 bouyer static int tl_multicast_hash __P((u_int8_t*));
189 1.1 bouyer static void tl_addr_filter __P((tl_softc_t*));
190 1.1 bouyer
191 1.1 bouyer static u_int32_t tl_intreg_read __P((tl_softc_t*, u_int32_t));
192 1.1 bouyer static void tl_intreg_write __P((tl_softc_t*, u_int32_t, u_int32_t));
193 1.1 bouyer static u_int8_t tl_intreg_read_byte __P((tl_softc_t*, u_int32_t));
194 1.1 bouyer static void tl_intreg_write_byte __P((tl_softc_t*, u_int32_t, u_int8_t));
195 1.1 bouyer
196 1.1 bouyer
197 1.1 bouyer #if defined(TLDEBUG_RX)
198 1.1 bouyer static void ether_printheader __P((struct ether_header*));
199 1.1 bouyer #endif
200 1.1 bouyer
201 1.1 bouyer void tl_mii_set __P((void*, u_int8_t));
202 1.1 bouyer void tl_mii_clr __P((void*, u_int8_t));
203 1.1 bouyer int tl_mii_read __P((void*, u_int8_t));
204 1.1 bouyer
205 1.1 bouyer void tl_i2c_set __P((void*, u_int8_t));
206 1.1 bouyer void tl_i2c_clr __P((void*, u_int8_t));
207 1.1 bouyer int tl_i2c_read __P((void*, u_int8_t));
208 1.1 bouyer
209 1.1 bouyer static __inline void netsio_clr __P((tl_softc_t*, u_int8_t));
210 1.1 bouyer static __inline void netsio_set __P((tl_softc_t*, u_int8_t));
211 1.1 bouyer static __inline u_int8_t netsio_read __P((tl_softc_t*, u_int8_t));
212 1.1 bouyer static __inline void netsio_clr(sc, bits)
213 1.1 bouyer tl_softc_t* sc;
214 1.1 bouyer u_int8_t bits;
215 1.1 bouyer {
216 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_NET + TL_INT_NetSio,
217 1.1 bouyer tl_intreg_read_byte(sc, TL_INT_NET + TL_INT_NetSio) & (~bits));
218 1.1 bouyer }
219 1.1 bouyer static __inline void netsio_set(sc, bits)
220 1.1 bouyer tl_softc_t* sc;
221 1.1 bouyer u_int8_t bits;
222 1.1 bouyer {
223 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_NET + TL_INT_NetSio,
224 1.1 bouyer tl_intreg_read_byte(sc, TL_INT_NET + TL_INT_NetSio) | bits);
225 1.1 bouyer }
226 1.1 bouyer static __inline u_int8_t netsio_read(sc, bits)
227 1.1 bouyer tl_softc_t* sc;
228 1.1 bouyer u_int8_t bits;
229 1.1 bouyer {
230 1.4 thorpej return (tl_intreg_read_byte(sc, TL_INT_NET + TL_INT_NetSio) & bits);
231 1.1 bouyer }
232 1.1 bouyer
233 1.1 bouyer struct cfattach tl_ca = {
234 1.4 thorpej sizeof(tl_softc_t), tl_pci_match, tl_pci_attach
235 1.1 bouyer };
236 1.1 bouyer
237 1.4 thorpej struct tl_product_desc {
238 1.4 thorpej u_int32_t tp_product;
239 1.4 thorpej u_int32_t tp_adapter;
240 1.10 thorpej int tp_flags;
241 1.4 thorpej const char *tp_desc;
242 1.4 thorpej };
243 1.4 thorpej
244 1.10 thorpej /* tp_flags */
245 1.10 thorpej #define TPF_BROKEN_MEM 0x00000001 /* memory-mapped access is broken */
246 1.10 thorpej
247 1.4 thorpej const struct tl_product_desc tl_compaq_products[] = {
248 1.4 thorpej { PCI_PRODUCT_COMPAQ_N100TX, COMPAQ_NETLIGENT_10_100,
249 1.10 thorpej 0, "Compaq Netelligent 10/100 TX" },
250 1.4 thorpej { PCI_PRODUCT_COMPAQ_N10T, COMPAQ_NETLIGENT_10,
251 1.10 thorpej 0, "Compaq Netelligent 10 T" },
252 1.4 thorpej { PCI_PRODUCT_COMPAQ_IntNF3P, COMPAQ_INT_NETFLEX,
253 1.10 thorpej 0, "Compaq Integrated NetFlex 3/P" },
254 1.4 thorpej { PCI_PRODUCT_COMPAQ_IntPL100TX, COMPAQ_INT_NETLIGENT_10_100,
255 1.10 thorpej 0, "Compaq ProLiant Integrated Netelligent 10/100 TX" },
256 1.4 thorpej { PCI_PRODUCT_COMPAQ_DPNet100TX, COMPAQ_DUAL_NETLIGENT_10_100,
257 1.10 thorpej 0, "Compaq Dual Port Netelligent 10/100 TX" },
258 1.4 thorpej { PCI_PRODUCT_COMPAQ_DP4000, COMPAQ_DSKP4000,
259 1.10 thorpej 0, "Compaq Deskpro 4000 5233MMX" },
260 1.4 thorpej { PCI_PRODUCT_COMPAQ_NF3P_BNC, COMPAQ_NETFLEX_BNC,
261 1.10 thorpej 0, "Compaq NetFlex 3/P w/ BNC" },
262 1.4 thorpej { PCI_PRODUCT_COMPAQ_NF3P, COMPAQ_NETFLEX,
263 1.10 thorpej 0, "Compaq NetFlex 3/P" },
264 1.4 thorpej { 0, 0, NULL },
265 1.4 thorpej };
266 1.4 thorpej
267 1.4 thorpej const struct tl_product_desc tl_ti_products[] = {
268 1.10 thorpej /*
269 1.10 thorpej * Built-in Ethernet on the TI TravelMate 5000
270 1.10 thorpej * docking station; better product description?
271 1.10 thorpej * XXX Seems to have broken memory-mapped access.
272 1.10 thorpej */
273 1.4 thorpej { PCI_PRODUCT_TI_TLAN, TI_TLAN,
274 1.10 thorpej TPF_BROKEN_MEM, "Texas Instruments ThunderLAN" },
275 1.4 thorpej { 0, 0, NULL },
276 1.4 thorpej };
277 1.4 thorpej
278 1.4 thorpej struct tl_vendor_desc {
279 1.4 thorpej u_int32_t tv_vendor;
280 1.4 thorpej const struct tl_product_desc *tv_products;
281 1.4 thorpej };
282 1.4 thorpej
283 1.4 thorpej const struct tl_vendor_desc tl_vendors[] = {
284 1.4 thorpej { PCI_VENDOR_COMPAQ, tl_compaq_products },
285 1.4 thorpej { PCI_VENDOR_TI, tl_ti_products },
286 1.4 thorpej { 0, NULL },
287 1.4 thorpej };
288 1.4 thorpej
289 1.4 thorpej const struct tl_product_desc *tl_lookup_product __P((u_int32_t));
290 1.4 thorpej
291 1.4 thorpej const struct tl_product_desc *
292 1.4 thorpej tl_lookup_product(id)
293 1.4 thorpej u_int32_t id;
294 1.4 thorpej {
295 1.4 thorpej const struct tl_product_desc *tp;
296 1.4 thorpej const struct tl_vendor_desc *tv;
297 1.4 thorpej
298 1.4 thorpej for (tv = tl_vendors; tv->tv_products != NULL; tv++)
299 1.4 thorpej if (PCI_VENDOR(id) == tv->tv_vendor)
300 1.4 thorpej break;
301 1.4 thorpej
302 1.4 thorpej if ((tp = tv->tv_products) == NULL)
303 1.4 thorpej return (NULL);
304 1.4 thorpej
305 1.4 thorpej for (; tp->tp_desc != NULL; tp++)
306 1.4 thorpej if (PCI_PRODUCT(id) == tp->tp_product)
307 1.4 thorpej break;
308 1.4 thorpej
309 1.4 thorpej if (tp->tp_desc == NULL)
310 1.4 thorpej return (NULL);
311 1.4 thorpej
312 1.4 thorpej return (tp);
313 1.4 thorpej }
314 1.4 thorpej
315 1.6 bouyer static char *nullbuf = NULL;
316 1.1 bouyer
317 1.1 bouyer static int
318 1.4 thorpej tl_pci_match(parent, match, aux)
319 1.1 bouyer struct device *parent;
320 1.7 drochner #ifdef __BROKEN_INDIRECT_CONFIG
321 1.1 bouyer void *match;
322 1.7 drochner #else
323 1.7 drochner struct cfdata *match;
324 1.7 drochner #endif
325 1.1 bouyer void *aux;
326 1.1 bouyer {
327 1.1 bouyer struct pci_attach_args *pa = (struct pci_attach_args *) aux;
328 1.1 bouyer
329 1.4 thorpej if (tl_lookup_product(pa->pa_id) != NULL)
330 1.4 thorpej return (1);
331 1.4 thorpej
332 1.4 thorpej return (0);
333 1.1 bouyer }
334 1.1 bouyer
335 1.1 bouyer static void
336 1.1 bouyer tl_pci_attach(parent, self, aux)
337 1.1 bouyer struct device * parent;
338 1.1 bouyer struct device * self;
339 1.1 bouyer void * aux;
340 1.1 bouyer {
341 1.1 bouyer tl_softc_t *sc = (tl_softc_t *)self;
342 1.1 bouyer struct pci_attach_args * const pa = (struct pci_attach_args *) aux;
343 1.4 thorpej const struct tl_product_desc *tp;
344 1.1 bouyer struct ifnet * const ifp = &sc->tl_if;
345 1.1 bouyer bus_space_tag_t iot, memt;
346 1.1 bouyer bus_space_handle_t ioh, memh;
347 1.1 bouyer pci_intr_handle_t intrhandle;
348 1.4 thorpej const char *intrstr;
349 1.4 thorpej int i, tmp, ioh_valid, memh_valid;
350 1.4 thorpej pcireg_t csr;
351 1.4 thorpej
352 1.4 thorpej printf("\n");
353 1.4 thorpej
354 1.10 thorpej tp = tl_lookup_product(pa->pa_id);
355 1.10 thorpej if (tp == NULL)
356 1.10 thorpej panic("tl_pci_attach: impossible");
357 1.10 thorpej
358 1.4 thorpej /* Map the card space. */
359 1.4 thorpej ioh_valid = (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0,
360 1.4 thorpej &iot, &ioh, NULL, NULL) == 0);
361 1.4 thorpej memh_valid = (pci_mapreg_map(pa, PCI_CBMA,
362 1.4 thorpej PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT,
363 1.4 thorpej 0, &memt, &memh, NULL, NULL) == 0);
364 1.4 thorpej
365 1.10 thorpej if (memh_valid && (tp->tp_flags & TPF_BROKEN_MEM) == 0) {
366 1.4 thorpej sc->tl_bustag = memt;
367 1.4 thorpej sc->tl_bushandle = memh;
368 1.4 thorpej } else if (ioh_valid) {
369 1.4 thorpej sc->tl_bustag = iot;
370 1.4 thorpej sc->tl_bushandle = ioh;
371 1.1 bouyer } else {
372 1.4 thorpej printf("%s: unable to map device registers\n",
373 1.4 thorpej sc->sc_dev.dv_xname);
374 1.4 thorpej return;
375 1.1 bouyer }
376 1.1 bouyer
377 1.4 thorpej /* Enable the device. */
378 1.4 thorpej csr = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
379 1.4 thorpej pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
380 1.4 thorpej csr | PCI_COMMAND_MASTER_ENABLE);
381 1.1 bouyer
382 1.4 thorpej printf("%s: %s\n", sc->sc_dev.dv_xname, tp->tp_desc);
383 1.4 thorpej sc->mii.adapter_id = tp->tp_adapter;
384 1.1 bouyer
385 1.1 bouyer tl_reset(sc);
386 1.1 bouyer
387 1.1 bouyer /* fill in the i2c struct */
388 1.1 bouyer sc->i2cbus.adapter_softc = sc;
389 1.1 bouyer sc->i2cbus.set_bit = tl_i2c_set;
390 1.1 bouyer sc->i2cbus.clr_bit = tl_i2c_clr;
391 1.1 bouyer sc->i2cbus.read_bit = tl_i2c_read;
392 1.1 bouyer
393 1.1 bouyer #ifdef TLDEBUG
394 1.1 bouyer printf("default values of INTreg: 0x%x\n",
395 1.1 bouyer tl_intreg_read(sc, TL_INT_Defaults));
396 1.1 bouyer #endif
397 1.1 bouyer
398 1.1 bouyer /* read mac addr */
399 1.1 bouyer for (i=0; i<ETHER_ADDR_LEN; i++) {
400 1.1 bouyer tmp = i2c_eeprom_read(&sc->i2cbus, 0x83 + i);
401 1.1 bouyer if (tmp < 0) {
402 1.4 thorpej printf("%s: error reading Ethernet adress\n",
403 1.4 thorpej sc->sc_dev.dv_xname);
404 1.1 bouyer return;
405 1.1 bouyer } else {
406 1.1 bouyer sc->tl_enaddr[i] = tmp;
407 1.1 bouyer }
408 1.1 bouyer }
409 1.4 thorpej printf("%s: Ethernet address %s\n", sc->sc_dev.dv_xname,
410 1.1 bouyer ether_sprintf(sc->tl_enaddr));
411 1.1 bouyer
412 1.4 thorpej /* Map and establish interrupts */
413 1.4 thorpej if (pci_intr_map(pa->pa_pc, pa->pa_intrtag, pa->pa_intrpin,
414 1.4 thorpej pa->pa_intrline, &intrhandle)) {
415 1.4 thorpej printf("%s: couldn't map interrupt\n", sc->sc_dev.dv_xname);
416 1.4 thorpej return;
417 1.4 thorpej }
418 1.4 thorpej intrstr = pci_intr_string(pa->pa_pc, intrhandle);
419 1.4 thorpej sc->tl_ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_NET,
420 1.4 thorpej tl_intr, sc);
421 1.4 thorpej if (sc->tl_ih == NULL) {
422 1.4 thorpej printf("%s: couldn't establish interrupt",
423 1.4 thorpej sc->sc_dev.dv_xname);
424 1.4 thorpej if (intrstr != NULL)
425 1.4 thorpej printf(" at %s", intrstr);
426 1.4 thorpej printf("\n");
427 1.4 thorpej return;
428 1.4 thorpej }
429 1.4 thorpej printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname, intrstr);
430 1.4 thorpej
431 1.4 thorpej /*
432 1.4 thorpej * Add shutdown hook so that DMA is disabled prior to reboot. Not
433 1.4 thorpej * doing do could allow DMA to corrupt kernel memory during the
434 1.4 thorpej * reboot before the driver initializes.
435 1.4 thorpej */
436 1.4 thorpej (void) shutdownhook_establish(tl_shutdown, sc);
437 1.4 thorpej
438 1.1 bouyer sc->mii.adapter_softc = sc;
439 1.1 bouyer sc->mii.mii_setbit = tl_mii_set;
440 1.1 bouyer sc->mii.mii_clrbit = tl_mii_clr;
441 1.1 bouyer sc->mii.mii_readbit = tl_mii_read;
442 1.1 bouyer sc->mii.mii_readreg = NULL; /* Let generic MII function handle that */
443 1.1 bouyer sc->mii.mii_writereg = NULL;
444 1.9 bouyer if (config_found(self, (void*)&sc->mii, mii_adapter_print) == NULL) {
445 1.1 bouyer return;
446 1.1 bouyer }
447 1.1 bouyer
448 1.1 bouyer ifmedia_init(&sc->tl_ifmedia, 0, tl_mediachange, tl_mediastatus);
449 1.1 bouyer mii_media_add(&sc->tl_ifmedia, &sc->mii);
450 1.1 bouyer ifmedia_set(&sc->tl_ifmedia, IFM_ETHER | IFM_NONE);
451 1.1 bouyer
452 1.1 bouyer bcopy(sc->sc_dev.dv_xname, sc->tl_if.if_xname, IFNAMSIZ);
453 1.1 bouyer sc->tl_if.if_softc = sc;
454 1.1 bouyer ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_NOTRAILERS|IFF_MULTICAST;
455 1.1 bouyer ifp->if_ioctl = tl_ifioctl;
456 1.1 bouyer ifp->if_start = tl_ifstart;
457 1.1 bouyer ifp->if_watchdog = tl_ifwatchdog;
458 1.1 bouyer ifp->if_timer = 0;
459 1.1 bouyer if_attach(ifp);
460 1.1 bouyer ether_ifattach(&(sc)->tl_if, (sc)->tl_enaddr);
461 1.1 bouyer #if NBPFILTER > 0
462 1.1 bouyer bpfattach(&sc->tl_bpf, &sc->tl_if, DLT_EN10MB,
463 1.1 bouyer sizeof(struct ether_header));
464 1.1 bouyer #endif
465 1.1 bouyer sc->mii.mii_media_active = IFM_NONE;
466 1.1 bouyer }
467 1.1 bouyer
468 1.1 bouyer static void
469 1.1 bouyer tl_reset(sc)
470 1.1 bouyer tl_softc_t *sc;
471 1.1 bouyer {
472 1.1 bouyer int i;
473 1.1 bouyer
474 1.1 bouyer /* read stats */
475 1.1 bouyer if (sc->tl_if.if_flags & IFF_RUNNING) {
476 1.1 bouyer untimeout(tl_ticks, sc);
477 1.1 bouyer tl_read_stats(sc);
478 1.1 bouyer }
479 1.1 bouyer /* Reset adapter */
480 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD,
481 1.1 bouyer TL_HR_READ(sc, TL_HOST_CMD) | HOST_CMD_Ad_Rst);
482 1.1 bouyer DELAY(100000);
483 1.1 bouyer /* Disable interrupts */
484 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, HOST_CMD_IntOff);
485 1.1 bouyer /* setup aregs & hash */
486 1.1 bouyer for (i = TL_INT_Areg0; i <= TL_INT_HASH2; i = i + 4)
487 1.1 bouyer tl_intreg_write(sc, i, 0);
488 1.1 bouyer #ifdef TLDEBUG_ADDR
489 1.1 bouyer printf("Areg & hash registers: \n");
490 1.1 bouyer for (i = TL_INT_Areg0; i <= TL_INT_HASH2; i = i + 4)
491 1.1 bouyer printf(" reg %x: %x\n", i, tl_intreg_read(sc, i));
492 1.1 bouyer #endif
493 1.1 bouyer /* Setup NetConfig */
494 1.1 bouyer tl_intreg_write(sc, TL_INT_NetConfig,
495 1.1 bouyer TL_NETCONFIG_1F | TL_NETCONFIG_1chn | TL_NETCONFIG_PHY_EN);
496 1.1 bouyer /* Bsize: accept default */
497 1.1 bouyer /* TX commit in Acommit: accept default */
498 1.1 bouyer /* Load Ld_tmr and Ld_thr */
499 1.1 bouyer /* Ld_tmr = 3 */
500 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, 0x3 | HOST_CMD_LdTmr);
501 1.1 bouyer /* Ld_thr = 0 */
502 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, 0x0 | HOST_CMD_LdThr);
503 1.1 bouyer /* Unreset MII */
504 1.1 bouyer netsio_set(sc, TL_NETSIO_NMRST);
505 1.1 bouyer DELAY(100000);
506 1.1 bouyer sc->mii.mii_media_status &= ~IFM_ACTIVE;
507 1.1 bouyer sc->tl_flags = 0;
508 1.1 bouyer sc->opkt = 0;
509 1.1 bouyer sc->stats_exesscoll = 0;
510 1.1 bouyer }
511 1.1 bouyer
512 1.1 bouyer static void tl_shutdown(v)
513 1.1 bouyer void *v;
514 1.1 bouyer {
515 1.1 bouyer tl_softc_t *sc = v;
516 1.1 bouyer struct Tx_list *Tx;
517 1.1 bouyer int i;
518 1.1 bouyer
519 1.1 bouyer if ((sc->tl_if.if_flags & IFF_RUNNING) == 0)
520 1.1 bouyer return;
521 1.1 bouyer /* disable interrupts */
522 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD,
523 1.1 bouyer HOST_CMD_IntOff);
524 1.1 bouyer /* stop TX and RX channels */
525 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD,
526 1.1 bouyer HOST_CMD_STOP | HOST_CMD_RT | HOST_CMD_Nes);
527 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, HOST_CMD_STOP);
528 1.1 bouyer DELAY(100000);
529 1.1 bouyer
530 1.1 bouyer /* stop statistics reading loop, read stats */
531 1.1 bouyer untimeout(tl_ticks, sc);
532 1.1 bouyer tl_read_stats(sc);
533 1.1 bouyer
534 1.1 bouyer /* deallocate memory allocations */
535 1.1 bouyer for (i=0; i< TL_NBUF; i++) {
536 1.1 bouyer if (sc->Rx_list[i].m)
537 1.1 bouyer m_freem(sc->Rx_list[i].m);
538 1.1 bouyer sc->Rx_list[i].m = NULL;
539 1.1 bouyer }
540 1.1 bouyer free(sc->Rx_list, M_DEVBUF);
541 1.1 bouyer sc->Rx_list = NULL;
542 1.1 bouyer while ((Tx = sc->active_Tx) != NULL) {
543 1.1 bouyer Tx->hw_list.stat = 0;
544 1.1 bouyer m_freem(Tx->m);
545 1.1 bouyer sc->active_Tx = Tx->next;
546 1.1 bouyer Tx->next = sc->Free_Tx;
547 1.1 bouyer sc->Free_Tx = Tx;
548 1.1 bouyer }
549 1.1 bouyer sc->last_Tx = NULL;
550 1.1 bouyer free(sc->Tx_list, M_DEVBUF);
551 1.1 bouyer sc->Tx_list = NULL;
552 1.1 bouyer sc->tl_if.if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
553 1.1 bouyer sc->mii.mii_media_status &= ~IFM_ACTIVE;
554 1.1 bouyer sc->tl_flags = 0;
555 1.1 bouyer }
556 1.1 bouyer
557 1.1 bouyer static void tl_restart(v)
558 1.1 bouyer void *v;
559 1.1 bouyer {
560 1.1 bouyer tl_init(v);
561 1.1 bouyer }
562 1.1 bouyer
563 1.1 bouyer static int tl_init(sc)
564 1.1 bouyer tl_softc_t *sc;
565 1.1 bouyer {
566 1.1 bouyer struct ifnet *ifp = &sc->tl_if;
567 1.1 bouyer int i, s;
568 1.1 bouyer
569 1.1 bouyer s = splimp();
570 1.1 bouyer /* cancel any pending IO */
571 1.1 bouyer tl_shutdown(sc);
572 1.1 bouyer tl_reset(sc);
573 1.1 bouyer if ((sc->tl_if.if_flags & IFF_UP) == 0) {
574 1.1 bouyer splx(s);
575 1.1 bouyer return 0;
576 1.1 bouyer }
577 1.1 bouyer /* Set various register to reasonable value */
578 1.1 bouyer /* setup NetCmd in promisc mode if needed */
579 1.1 bouyer i = (ifp->if_flags & IFF_PROMISC) ? TL_NETCOMMAND_CAF : 0;
580 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_NET + TL_INT_NetCmd,
581 1.1 bouyer TL_NETCOMMAND_NRESET | TL_NETCOMMAND_NWRAP | i);
582 1.1 bouyer /* Max receive size : MCLBYTES */
583 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_MISC + TL_MISC_MaxRxL, MCLBYTES & 0xff);
584 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_MISC + TL_MISC_MaxRxH,
585 1.1 bouyer (MCLBYTES >> 8) & 0xff);
586 1.1 bouyer
587 1.1 bouyer /* init MAC addr */
588 1.1 bouyer for (i = 0; i < ETHER_ADDR_LEN; i++)
589 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_Areg0 + i , sc->tl_enaddr[i]);
590 1.1 bouyer /* add multicast filters */
591 1.1 bouyer tl_addr_filter(sc);
592 1.1 bouyer #ifdef TLDEBUG_ADDR
593 1.1 bouyer printf("Wrote Mac addr, Areg & hash registers are now: \n");
594 1.1 bouyer for (i = TL_INT_Areg0; i <= TL_INT_HASH2; i = i + 4)
595 1.1 bouyer printf(" reg %x: %x\n", i, tl_intreg_read(sc, i));
596 1.1 bouyer #endif
597 1.1 bouyer
598 1.1 bouyer /* Pre-allocate receivers mbuf, make the lists */
599 1.1 bouyer sc->Rx_list = malloc(sizeof(struct Rx_list) * TL_NBUF, M_DEVBUF, M_NOWAIT);
600 1.1 bouyer sc->Tx_list = malloc(sizeof(struct Tx_list) * TL_NBUF, M_DEVBUF, M_NOWAIT);
601 1.1 bouyer if (sc->Rx_list == NULL || sc->Tx_list == NULL) {
602 1.1 bouyer printf("%s: out of memory for lists\n", sc->sc_dev.dv_xname);
603 1.1 bouyer sc->tl_if.if_flags &= ~IFF_UP;
604 1.1 bouyer splx(s);
605 1.1 bouyer return ENOMEM;
606 1.1 bouyer }
607 1.1 bouyer for (i=0; i< TL_NBUF; i++) {
608 1.1 bouyer if(tl_add_RxBuff(&sc->Rx_list[i], NULL) == 0) {
609 1.1 bouyer printf("%s: out of mbuf for receive list\n", sc->sc_dev.dv_xname);
610 1.1 bouyer sc->tl_if.if_flags &= ~IFF_UP;
611 1.1 bouyer splx(s);
612 1.1 bouyer return ENOMEM;
613 1.1 bouyer }
614 1.1 bouyer if (i > 0) { /* chain the list */
615 1.1 bouyer sc->Rx_list[i-1].next = &sc->Rx_list[i];
616 1.1 bouyer sc->Rx_list[i-1].hw_list.fwd = vtophys(&sc->Rx_list[i].hw_list);
617 1.1 bouyer #ifdef DIAGNOSTIC
618 1.1 bouyer if (sc->Rx_list[i-1].hw_list.fwd & 0x7)
619 1.1 bouyer printf("%s: physical addr 0x%x of list not properly aligned\n",
620 1.1 bouyer sc->sc_dev.dv_xname, sc->Rx_list[i-1].hw_list.fwd);
621 1.1 bouyer #endif
622 1.1 bouyer sc->Tx_list[i-1].next = &sc->Tx_list[i];
623 1.1 bouyer }
624 1.1 bouyer }
625 1.1 bouyer sc->Rx_list[TL_NBUF-1].next = NULL;
626 1.1 bouyer sc->Rx_list[TL_NBUF-1].hw_list.fwd = 0;
627 1.1 bouyer sc->Tx_list[TL_NBUF-1].next = NULL;
628 1.1 bouyer
629 1.1 bouyer sc->active_Rx = &sc->Rx_list[0];
630 1.1 bouyer sc->last_Rx = &sc->Rx_list[TL_NBUF-1];
631 1.1 bouyer sc->active_Tx = sc->last_Tx = NULL;
632 1.1 bouyer sc->Free_Tx = &sc->Tx_list[0];
633 1.1 bouyer
634 1.6 bouyer if (nullbuf == NULL)
635 1.6 bouyer nullbuf = malloc(ETHER_MIN_TX, M_DEVBUF, M_NOWAIT);
636 1.1 bouyer if (nullbuf == NULL) {
637 1.1 bouyer printf("%s: can't allocate space for pad buffer\n",
638 1.1 bouyer sc->sc_dev.dv_xname);
639 1.1 bouyer sc->tl_if.if_flags &= ~IFF_UP;
640 1.1 bouyer splx(s);
641 1.1 bouyer return ENOMEM;
642 1.1 bouyer }
643 1.1 bouyer bzero(nullbuf, ETHER_MIN_TX);
644 1.1 bouyer
645 1.1 bouyer /* set media if needed */
646 1.1 bouyer if (IFM_SUBTYPE(sc->mii.mii_media_active) != IFM_NONE) {
647 1.1 bouyer mii_mediachg(&sc->mii);
648 1.1 bouyer }
649 1.1 bouyer
650 1.1 bouyer /* start ticks calls */
651 1.1 bouyer timeout(tl_ticks, sc, hz);
652 1.1 bouyer /* write adress of Rx list and enable interrupts */
653 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CH_PARM, vtophys(&sc->Rx_list[0].hw_list));
654 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD,
655 1.1 bouyer HOST_CMD_GO | HOST_CMD_RT | HOST_CMD_Nes | HOST_CMD_IntOn);
656 1.1 bouyer sc->tl_if.if_flags |= IFF_RUNNING;
657 1.1 bouyer sc->tl_if.if_flags &= ~IFF_OACTIVE;
658 1.1 bouyer return 0;
659 1.1 bouyer }
660 1.1 bouyer
661 1.1 bouyer
662 1.1 bouyer static u_int32_t
663 1.1 bouyer tl_intreg_read(sc, reg)
664 1.1 bouyer tl_softc_t *sc;
665 1.1 bouyer u_int32_t reg;
666 1.1 bouyer {
667 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_INTR_DIOADR, reg & TL_HOST_DIOADR_MASK);
668 1.1 bouyer return TL_HR_READ(sc, TL_HOST_DIO_DATA);
669 1.1 bouyer }
670 1.1 bouyer
671 1.1 bouyer static u_int8_t
672 1.1 bouyer tl_intreg_read_byte(sc, reg)
673 1.1 bouyer tl_softc_t *sc;
674 1.1 bouyer u_int32_t reg;
675 1.1 bouyer {
676 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_INTR_DIOADR,
677 1.1 bouyer (reg & (~0x07)) & TL_HOST_DIOADR_MASK);
678 1.1 bouyer return TL_HR_READ_BYTE(sc, TL_HOST_DIO_DATA + (reg & 0x07));
679 1.1 bouyer }
680 1.1 bouyer
681 1.1 bouyer static void
682 1.1 bouyer tl_intreg_write(sc, reg, val)
683 1.1 bouyer tl_softc_t *sc;
684 1.1 bouyer u_int32_t reg;
685 1.1 bouyer u_int32_t val;
686 1.1 bouyer {
687 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_INTR_DIOADR, reg & TL_HOST_DIOADR_MASK);
688 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_DIO_DATA, val);
689 1.1 bouyer }
690 1.1 bouyer
691 1.1 bouyer static void
692 1.1 bouyer tl_intreg_write_byte(sc, reg, val)
693 1.1 bouyer tl_softc_t *sc;
694 1.1 bouyer u_int32_t reg;
695 1.1 bouyer u_int8_t val;
696 1.1 bouyer {
697 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_INTR_DIOADR,
698 1.1 bouyer (reg & (~0x03)) & TL_HOST_DIOADR_MASK);
699 1.1 bouyer TL_HR_WRITE_BYTE(sc, TL_HOST_DIO_DATA + (reg & 0x03), val);
700 1.1 bouyer }
701 1.1 bouyer
702 1.1 bouyer void tl_mii_set(v, bit)
703 1.1 bouyer void *v;
704 1.1 bouyer u_int8_t bit;
705 1.1 bouyer {
706 1.1 bouyer tl_softc_t *sc = v;
707 1.1 bouyer
708 1.1 bouyer switch (bit) {
709 1.1 bouyer case MII_DATA:
710 1.1 bouyer netsio_set(sc, TL_NETSIO_MDATA);
711 1.1 bouyer break;
712 1.1 bouyer case MII_CLOCK:
713 1.1 bouyer netsio_set(sc, TL_NETSIO_MCLK);
714 1.1 bouyer break;
715 1.1 bouyer case MII_TXEN:
716 1.1 bouyer netsio_set(sc, TL_NETSIO_MTXEN);
717 1.1 bouyer break;
718 1.1 bouyer default:
719 1.1 bouyer printf("tl_mii_set: unknown bit %d\n", bit);
720 1.1 bouyer }
721 1.1 bouyer }
722 1.1 bouyer
723 1.1 bouyer void tl_mii_clr(v, bit)
724 1.1 bouyer void *v;
725 1.1 bouyer u_int8_t bit;
726 1.1 bouyer {
727 1.1 bouyer tl_softc_t *sc = v;
728 1.1 bouyer
729 1.1 bouyer switch (bit) {
730 1.1 bouyer case MII_DATA:
731 1.1 bouyer netsio_clr(sc, TL_NETSIO_MDATA);
732 1.1 bouyer break;
733 1.1 bouyer case MII_CLOCK:
734 1.1 bouyer netsio_clr(sc, TL_NETSIO_MCLK);
735 1.1 bouyer break;
736 1.1 bouyer case MII_TXEN:
737 1.1 bouyer netsio_clr(sc, TL_NETSIO_MTXEN);
738 1.1 bouyer break;
739 1.1 bouyer default:
740 1.1 bouyer printf("tl_mii_clr: unknown bit %d\n", bit);
741 1.1 bouyer }
742 1.1 bouyer return;
743 1.1 bouyer }
744 1.1 bouyer
745 1.1 bouyer int tl_mii_read(v, bit)
746 1.1 bouyer void *v;
747 1.1 bouyer u_int8_t bit;
748 1.1 bouyer {
749 1.1 bouyer tl_softc_t *sc = v;
750 1.1 bouyer
751 1.1 bouyer switch (bit) {
752 1.1 bouyer case MII_DATA:
753 1.1 bouyer return netsio_read(sc, TL_NETSIO_MDATA);
754 1.1 bouyer break;
755 1.1 bouyer case MII_CLOCK:
756 1.1 bouyer return netsio_read(sc, TL_NETSIO_MCLK);
757 1.1 bouyer break;
758 1.1 bouyer case MII_TXEN:
759 1.1 bouyer return netsio_read(sc, TL_NETSIO_MTXEN);
760 1.1 bouyer break;
761 1.1 bouyer default:
762 1.1 bouyer printf("tl_mii_read: unknown bit %d\n", bit);
763 1.1 bouyer return -1;
764 1.1 bouyer }
765 1.1 bouyer }
766 1.1 bouyer
767 1.1 bouyer void tl_i2c_set(v, bit)
768 1.1 bouyer void *v;
769 1.1 bouyer u_int8_t bit;
770 1.1 bouyer {
771 1.1 bouyer tl_softc_t *sc = v;
772 1.1 bouyer
773 1.1 bouyer switch (bit) {
774 1.1 bouyer case I2C_DATA:
775 1.1 bouyer netsio_set(sc, TL_NETSIO_EDATA);
776 1.1 bouyer break;
777 1.1 bouyer case I2C_CLOCK:
778 1.1 bouyer netsio_set(sc, TL_NETSIO_ECLOCK);
779 1.1 bouyer break;
780 1.1 bouyer case I2C_TXEN:
781 1.1 bouyer netsio_set(sc, TL_NETSIO_ETXEN);
782 1.1 bouyer break;
783 1.1 bouyer default:
784 1.1 bouyer printf("tl_i2c_set: unknown bit %d\n", bit);
785 1.1 bouyer }
786 1.1 bouyer return;
787 1.1 bouyer }
788 1.1 bouyer
789 1.1 bouyer void tl_i2c_clr(v, bit)
790 1.1 bouyer void *v;
791 1.1 bouyer u_int8_t bit;
792 1.1 bouyer {
793 1.1 bouyer tl_softc_t *sc = v;
794 1.1 bouyer
795 1.1 bouyer switch (bit) {
796 1.1 bouyer case I2C_DATA:
797 1.1 bouyer netsio_clr(sc, TL_NETSIO_EDATA);
798 1.1 bouyer break;
799 1.1 bouyer case I2C_CLOCK:
800 1.1 bouyer netsio_clr(sc, TL_NETSIO_ECLOCK);
801 1.1 bouyer break;
802 1.1 bouyer case I2C_TXEN:
803 1.1 bouyer netsio_clr(sc, TL_NETSIO_ETXEN);
804 1.1 bouyer break;
805 1.1 bouyer default:
806 1.1 bouyer printf("tl_i2c_clr: unknown bit %d\n", bit);
807 1.1 bouyer }
808 1.1 bouyer return;
809 1.1 bouyer }
810 1.1 bouyer
811 1.1 bouyer int tl_i2c_read(v, bit)
812 1.1 bouyer void *v;
813 1.1 bouyer u_int8_t bit;
814 1.1 bouyer {
815 1.1 bouyer tl_softc_t *sc = v;
816 1.1 bouyer
817 1.1 bouyer switch (bit) {
818 1.1 bouyer case I2C_DATA:
819 1.1 bouyer return netsio_read(sc, TL_NETSIO_EDATA);
820 1.1 bouyer break;
821 1.1 bouyer case I2C_CLOCK:
822 1.1 bouyer return netsio_read(sc, TL_NETSIO_ECLOCK);
823 1.1 bouyer break;
824 1.1 bouyer case I2C_TXEN:
825 1.1 bouyer return netsio_read(sc, TL_NETSIO_ETXEN);
826 1.1 bouyer break;
827 1.1 bouyer default:
828 1.1 bouyer printf("tl_i2c_read: unknown bit %d\n", bit);
829 1.1 bouyer return -1;
830 1.1 bouyer }
831 1.1 bouyer }
832 1.1 bouyer
833 1.1 bouyer static int
834 1.1 bouyer tl_intr(v)
835 1.1 bouyer void *v;
836 1.1 bouyer {
837 1.1 bouyer tl_softc_t *sc = v;
838 1.1 bouyer struct ifnet *ifp = &sc->tl_if;
839 1.1 bouyer struct Rx_list *Rx;
840 1.1 bouyer struct Tx_list *Tx;
841 1.1 bouyer struct mbuf *m;
842 1.1 bouyer u_int32_t int_type, int_reg;
843 1.1 bouyer int ack = 0;
844 1.1 bouyer int size;
845 1.1 bouyer
846 1.1 bouyer int_reg = TL_HR_READ(sc, TL_HOST_INTR_DIOADR);
847 1.1 bouyer int_type = int_reg & TL_INTR_MASK;
848 1.1 bouyer if (int_type == 0)
849 1.1 bouyer return 0;
850 1.1 bouyer #if defined(TLDEBUG_RX) || defined(TLDEBUG_TX)
851 1.1 bouyer printf("%s: interrupt type %x, intr_reg %x\n", sc->sc_dev.dv_xname,
852 1.1 bouyer int_type, int_reg);
853 1.1 bouyer #endif
854 1.1 bouyer /* disable interrupts */
855 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, HOST_CMD_IntOff);
856 1.1 bouyer switch(int_type & TL_INTR_MASK) {
857 1.1 bouyer case TL_INTR_RxEOF:
858 1.1 bouyer while(sc->active_Rx->hw_list.stat & TL_RX_CSTAT_CPLT) {
859 1.1 bouyer /* dequeue and requeue at end of list */
860 1.1 bouyer ack++;
861 1.1 bouyer Rx = sc->active_Rx;
862 1.1 bouyer sc->active_Rx = Rx->next;
863 1.1 bouyer m = Rx->m;
864 1.1 bouyer size = Rx->hw_list.stat >> 16;
865 1.1 bouyer #ifdef TLDEBUG_RX
866 1.1 bouyer printf("tl_intr: RX list complete, Rx %p, size=%d\n", Rx, size);
867 1.1 bouyer #endif
868 1.1 bouyer if (tl_add_RxBuff(Rx, m ) == 0) {
869 1.1 bouyer /* No new mbuf, reuse the same. This means that this packet
870 1.1 bouyer is lost */
871 1.1 bouyer m = NULL;
872 1.1 bouyer #ifdef TL_PRIV_STATS
873 1.1 bouyer sc->ierr_nomem++;
874 1.1 bouyer #endif
875 1.1 bouyer #ifdef TLDEBUG
876 1.1 bouyer printf("%s: out of mbuf, lost input packet\n",
877 1.1 bouyer sc->sc_dev.dv_xname);
878 1.1 bouyer #endif
879 1.1 bouyer }
880 1.1 bouyer Rx->next = NULL;
881 1.1 bouyer Rx->hw_list.fwd = 0;
882 1.1 bouyer sc->last_Rx->hw_list.fwd = vtophys(&Rx->hw_list);
883 1.1 bouyer #ifdef DIAGNOSTIC
884 1.1 bouyer if (sc->last_Rx->hw_list.fwd & 0x7)
885 1.1 bouyer printf("%s: physical addr 0x%x of list not properly aligned\n",
886 1.1 bouyer sc->sc_dev.dv_xname, sc->last_Rx->hw_list.fwd);
887 1.1 bouyer #endif
888 1.1 bouyer sc->last_Rx->next = Rx;
889 1.1 bouyer sc->last_Rx = Rx;
890 1.1 bouyer
891 1.1 bouyer /* deliver packet */
892 1.1 bouyer if (m) {
893 1.1 bouyer struct ether_header *eh;
894 1.1 bouyer if (size < sizeof(struct ether_header)) {
895 1.1 bouyer m_freem(m);
896 1.1 bouyer continue;
897 1.1 bouyer }
898 1.1 bouyer m->m_pkthdr.rcvif = ifp;
899 1.1 bouyer m->m_pkthdr.len = m->m_len =
900 1.1 bouyer size - sizeof(struct ether_header);
901 1.1 bouyer eh = mtod(m, struct ether_header *);
902 1.1 bouyer #ifdef TLDEBUG_RX
903 1.1 bouyer printf("tl_intr: Rx packet:\n");
904 1.1 bouyer ether_printheader(eh);
905 1.1 bouyer #endif
906 1.1 bouyer #if NBPFILTER > 0
907 1.1 bouyer if (ifp->if_bpf) {
908 1.1 bouyer bpf_tap(ifp->if_bpf,
909 1.1 bouyer mtod(m, caddr_t),
910 1.1 bouyer size);
911 1.1 bouyer /*
912 1.1 bouyer * Only pass this packet up
913 1.1 bouyer * if it is for us.
914 1.1 bouyer */
915 1.1 bouyer if ((ifp->if_flags & IFF_PROMISC) &&
916 1.1 bouyer (eh->ether_dhost[0] & 1) == 0 && /* !mcast and !bcast */
917 1.1 bouyer bcmp(eh->ether_dhost, LLADDR(ifp->if_sadl),
918 1.1 bouyer sizeof(eh->ether_dhost)) != 0) {
919 1.1 bouyer m_freem(m);
920 1.1 bouyer continue;
921 1.1 bouyer }
922 1.1 bouyer }
923 1.1 bouyer #endif /* NBPFILTER > 0 */
924 1.1 bouyer m->m_data += sizeof(struct ether_header);
925 1.1 bouyer ether_input(ifp, eh, m);
926 1.1 bouyer }
927 1.1 bouyer }
928 1.1 bouyer #ifdef TLDEBUG_RX
929 1.1 bouyer printf("TL_INTR_RxEOF: ack %d\n", ack);
930 1.1 bouyer #else
931 1.1 bouyer if (ack == 0) {
932 1.1 bouyer printf("%s: EOF intr without anything to read !\n",
933 1.1 bouyer sc->sc_dev.dv_xname);
934 1.1 bouyer tl_reset(sc);
935 1.1 bouyer /* shedule reinit of the board */
936 1.1 bouyer timeout(tl_restart, sc, 1);
937 1.1 bouyer return(1);
938 1.1 bouyer }
939 1.1 bouyer #endif
940 1.1 bouyer break;
941 1.1 bouyer case TL_INTR_RxEOC:
942 1.1 bouyer ack++;
943 1.1 bouyer #ifdef TLDEBUG_RX
944 1.1 bouyer printf("TL_INTR_RxEOC: ack %d\n", ack);
945 1.1 bouyer #endif
946 1.1 bouyer #ifdef DIAGNOSTIC
947 1.1 bouyer if (sc->active_Rx->hw_list.stat & TL_RX_CSTAT_CPLT) {
948 1.1 bouyer printf("%s: Rx EOC interrupt and active Rx list not cleared\n",
949 1.1 bouyer sc->sc_dev.dv_xname);
950 1.1 bouyer return 0;
951 1.1 bouyer } else
952 1.1 bouyer #endif
953 1.1 bouyer {
954 1.1 bouyer /* write adress of Rx list and send Rx GO command, ack interrupt
955 1.1 bouyer and enable interrupts in one command */
956 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CH_PARM,
957 1.1 bouyer vtophys(&sc->active_Rx->hw_list));
958 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD,
959 1.1 bouyer HOST_CMD_GO | HOST_CMD_RT | HOST_CMD_Nes | ack | int_type |
960 1.1 bouyer HOST_CMD_ACK | HOST_CMD_IntOn);
961 1.1 bouyer return 1;
962 1.1 bouyer }
963 1.1 bouyer case TL_INTR_TxEOF:
964 1.1 bouyer case TL_INTR_TxEOC:
965 1.1 bouyer while ((Tx = sc->active_Tx) != NULL) {
966 1.1 bouyer if((Tx->hw_list.stat & TL_TX_CSTAT_CPLT) == 0)
967 1.1 bouyer break;
968 1.1 bouyer ack++;
969 1.1 bouyer #ifdef TLDEBUG_TX
970 1.1 bouyer printf("TL_INTR_TxEOC: list 0x%xp done\n", vtophys(&Tx->hw_list));
971 1.1 bouyer #endif
972 1.1 bouyer Tx->hw_list.stat = 0;
973 1.1 bouyer m_freem(Tx->m);
974 1.1 bouyer Tx->m = NULL;
975 1.1 bouyer sc->active_Tx = Tx->next;
976 1.1 bouyer if (sc->active_Tx == NULL)
977 1.1 bouyer sc->last_Tx = NULL;
978 1.1 bouyer Tx->next = sc->Free_Tx;
979 1.1 bouyer sc->Free_Tx = Tx;
980 1.1 bouyer }
981 1.1 bouyer /* if this was an EOC, ACK immediatly */
982 1.1 bouyer if (int_type == TL_INTR_TxEOC) {
983 1.1 bouyer #ifdef TLDEBUG_TX
984 1.1 bouyer printf("TL_INTR_TxEOC: ack %d (will be set to 1)\n", ack);
985 1.1 bouyer #endif
986 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, 1 | int_type | HOST_CMD_ACK |
987 1.1 bouyer HOST_CMD_IntOn);
988 1.1 bouyer if ( sc->active_Tx != NULL) { /* needs a Tx go command */
989 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CH_PARM,
990 1.1 bouyer vtophys(&sc->active_Tx->hw_list));
991 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, HOST_CMD_GO);
992 1.1 bouyer }
993 1.1 bouyer sc->tl_if.if_timer = 0;
994 1.1 bouyer if (sc->tl_if.if_snd.ifq_head != NULL)
995 1.1 bouyer tl_ifstart(&sc->tl_if);
996 1.1 bouyer return 1;
997 1.1 bouyer }
998 1.1 bouyer #ifdef TLDEBUG
999 1.1 bouyer else {
1000 1.1 bouyer printf("TL_INTR_TxEOF: ack %d\n", ack);
1001 1.1 bouyer }
1002 1.1 bouyer #endif
1003 1.1 bouyer sc->tl_if.if_timer = 0;
1004 1.1 bouyer if (sc->tl_if.if_snd.ifq_head != NULL)
1005 1.1 bouyer tl_ifstart(&sc->tl_if);
1006 1.1 bouyer break;
1007 1.1 bouyer case TL_INTR_Stat:
1008 1.1 bouyer ack++;
1009 1.1 bouyer #ifdef TLDEBUG
1010 1.1 bouyer printf("TL_INTR_Stat: ack %d\n", ack);
1011 1.1 bouyer #endif
1012 1.1 bouyer tl_read_stats(sc);
1013 1.1 bouyer break;
1014 1.1 bouyer case TL_INTR_Adc:
1015 1.1 bouyer if (int_reg & TL_INTVec_MASK) {
1016 1.1 bouyer /* adapter check conditions */
1017 1.1 bouyer printf("%s: check condition, intvect=0x%x, ch_param=0x%x\n",
1018 1.1 bouyer sc->sc_dev.dv_xname, int_reg & TL_INTVec_MASK,
1019 1.1 bouyer TL_HR_READ(sc, TL_HOST_CH_PARM));
1020 1.1 bouyer tl_reset(sc);
1021 1.1 bouyer /* shedule reinit of the board */
1022 1.1 bouyer timeout(tl_restart, sc, 1);
1023 1.1 bouyer return(1);
1024 1.1 bouyer } else {
1025 1.1 bouyer u_int8_t netstat;
1026 1.1 bouyer /* Network status */
1027 1.1 bouyer netstat = tl_intreg_read_byte(sc, TL_INT_NET+TL_INT_NetSts);
1028 1.1 bouyer printf("%s: network status, NetSts=%x\n",
1029 1.1 bouyer sc->sc_dev.dv_xname, netstat);
1030 1.1 bouyer /* Ack interrupts */
1031 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_NET+TL_INT_NetSts, netstat);
1032 1.1 bouyer ack++;
1033 1.1 bouyer }
1034 1.1 bouyer break;
1035 1.1 bouyer default:
1036 1.1 bouyer printf("%s: unhandled interrupt code %x!\n",
1037 1.1 bouyer sc->sc_dev.dv_xname, int_type);
1038 1.1 bouyer ack++;
1039 1.1 bouyer }
1040 1.1 bouyer
1041 1.1 bouyer if (ack) {
1042 1.1 bouyer /* Ack the interrupt and enable interrupts */
1043 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, ack | int_type | HOST_CMD_ACK |
1044 1.1 bouyer HOST_CMD_IntOn);
1045 1.1 bouyer return 1;
1046 1.1 bouyer }
1047 1.1 bouyer /* ack = 0 ; interrupt was perhaps not our. Just enable interrupts */
1048 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, HOST_CMD_IntOn);
1049 1.1 bouyer return 0;
1050 1.1 bouyer }
1051 1.1 bouyer
1052 1.1 bouyer static int
1053 1.1 bouyer tl_ifioctl(ifp, cmd, data)
1054 1.1 bouyer struct ifnet *ifp;
1055 1.1 bouyer ioctl_cmd_t cmd;
1056 1.1 bouyer caddr_t data;
1057 1.1 bouyer {
1058 1.1 bouyer struct tl_softc *sc = ifp->if_softc;
1059 1.1 bouyer struct ifreq *ifr = (struct ifreq *)data;
1060 1.1 bouyer int s, error;
1061 1.1 bouyer
1062 1.1 bouyer s = splimp();
1063 1.1 bouyer switch(cmd) {
1064 1.1 bouyer case SIOCSIFADDR: {
1065 1.1 bouyer struct ifaddr *ifa = (struct ifaddr *)data;
1066 1.1 bouyer sc->tl_if.if_flags |= IFF_UP;
1067 1.1 bouyer if ((error = tl_init(sc)) != NULL) {
1068 1.1 bouyer sc->tl_if.if_flags &= ~IFF_UP;
1069 1.1 bouyer break;
1070 1.1 bouyer }
1071 1.1 bouyer switch (ifa->ifa_addr->sa_family) {
1072 1.1 bouyer #ifdef INET
1073 1.1 bouyer case AF_INET:
1074 1.1 bouyer arp_ifinit(ifp, ifa);
1075 1.1 bouyer break;
1076 1.1 bouyer #endif
1077 1.1 bouyer #ifdef NS
1078 1.1 bouyer case AF_NS: {
1079 1.1 bouyer struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
1080 1.1 bouyer
1081 1.1 bouyer if (ns_nullhost(*ina))
1082 1.1 bouyer ina->x_host = *(union ns_host*) LLADDR(ifp->if_sadl);
1083 1.1 bouyer else
1084 1.1 bouyer bcopy(ina->x_host.c_host, LLADDR(ifp->if_sadl),
1085 1.1 bouyer ifp->if_addrlen);
1086 1.1 bouyer break;
1087 1.1 bouyer }
1088 1.1 bouyer #endif
1089 1.1 bouyer default:
1090 1.1 bouyer break;
1091 1.1 bouyer }
1092 1.1 bouyer break;
1093 1.1 bouyer }
1094 1.1 bouyer case SIOCSIFFLAGS:
1095 1.1 bouyer {
1096 1.1 bouyer u_int8_t reg;
1097 1.1 bouyer /*
1098 1.1 bouyer * If interface is marked up and not running, then start it.
1099 1.1 bouyer * If it is marked down and running, stop it.
1100 1.1 bouyer */
1101 1.1 bouyer if (ifp->if_flags & IFF_UP) {
1102 1.1 bouyer if ((ifp->if_flags & IFF_RUNNING) == 0) {
1103 1.1 bouyer error = tl_init(sc);
1104 1.1 bouyer /* all flags have been handled by init */
1105 1.1 bouyer break;
1106 1.1 bouyer }
1107 1.1 bouyer error = 0;
1108 1.1 bouyer reg = tl_intreg_read_byte(sc, TL_INT_NET + TL_INT_NetCmd);
1109 1.1 bouyer if (ifp->if_flags & IFF_PROMISC)
1110 1.1 bouyer reg |= TL_NETCOMMAND_CAF;
1111 1.1 bouyer else
1112 1.1 bouyer reg &= ~TL_NETCOMMAND_CAF;
1113 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_NET + TL_INT_NetCmd, reg);
1114 1.1 bouyer #ifdef TL_PRIV_STATS
1115 1.1 bouyer if (ifp->if_flags & IFF_LINK0) {
1116 1.1 bouyer ifp->if_flags &= ~IFF_LINK0;
1117 1.1 bouyer printf("%s errors statistics\n", sc->sc_dev.dv_xname);
1118 1.1 bouyer printf(" %4d RX buffer overrun\n",sc->ierr_overr);
1119 1.1 bouyer printf(" %4d RX code error\n", sc->ierr_code);
1120 1.1 bouyer printf(" %4d RX crc error\n", sc->ierr_crc);
1121 1.1 bouyer printf(" %4d RX out of memory\n", sc->ierr_nomem);
1122 1.1 bouyer printf(" %4d TX buffer underrun\n", sc->oerr_underr);
1123 1.1 bouyer printf(" %4d TX deffered frames\n", sc->oerr_deffered);
1124 1.1 bouyer printf(" %4d TX single collisions\n", sc->oerr_coll);
1125 1.1 bouyer printf(" %4d TX multi collisions\n", sc->oerr_multicoll);
1126 1.1 bouyer printf(" %4d TX exessive collisions\n", sc->oerr_exesscoll);
1127 1.1 bouyer printf(" %4d TX late collisions\n", sc->oerr_latecoll);
1128 1.1 bouyer printf(" %4d TX carrier loss\n", sc->oerr_carrloss);
1129 1.1 bouyer printf(" %4d TX mbuf copy\n", sc->oerr_mcopy);
1130 1.1 bouyer }
1131 1.1 bouyer #endif
1132 1.1 bouyer } else {
1133 1.1 bouyer if (ifp->if_flags & IFF_RUNNING)
1134 1.1 bouyer tl_shutdown(sc);
1135 1.1 bouyer error = 0;
1136 1.1 bouyer }
1137 1.1 bouyer break;
1138 1.1 bouyer }
1139 1.1 bouyer case SIOCADDMULTI:
1140 1.1 bouyer case SIOCDELMULTI:
1141 1.1 bouyer /*
1142 1.1 bouyer * Update multicast listeners
1143 1.1 bouyer */
1144 1.1 bouyer if (cmd == SIOCADDMULTI)
1145 1.1 bouyer error = ether_addmulti(ifr, &sc->tl_ec);
1146 1.1 bouyer else
1147 1.1 bouyer error = ether_delmulti(ifr, &sc->tl_ec);
1148 1.1 bouyer if (error == ENETRESET) {
1149 1.1 bouyer tl_addr_filter(sc);
1150 1.1 bouyer error = 0;
1151 1.1 bouyer }
1152 1.1 bouyer break;
1153 1.1 bouyer case SIOCSIFMEDIA:
1154 1.1 bouyer case SIOCGIFMEDIA:
1155 1.1 bouyer error = ifmedia_ioctl(ifp, ifr, &sc->tl_ifmedia, cmd);
1156 1.1 bouyer break;
1157 1.1 bouyer default:
1158 1.1 bouyer error = EINVAL;
1159 1.1 bouyer }
1160 1.1 bouyer splx(s);
1161 1.1 bouyer return error;
1162 1.1 bouyer }
1163 1.1 bouyer
1164 1.1 bouyer static void
1165 1.1 bouyer tl_ifstart(ifp)
1166 1.1 bouyer struct ifnet *ifp;
1167 1.1 bouyer {
1168 1.1 bouyer tl_softc_t *sc = ifp->if_softc;
1169 1.1 bouyer struct mbuf *m, *mb_head;
1170 1.1 bouyer struct Tx_list *Tx;
1171 1.1 bouyer int segment, size;
1172 1.1 bouyer
1173 1.1 bouyer txloop:
1174 1.1 bouyer /* If we don't have more space ... */
1175 1.1 bouyer if (sc->Free_Tx == NULL) {
1176 1.1 bouyer #ifdef TLDEBUG
1177 1.1 bouyer printf("tl_ifstart: No free TX list\n");
1178 1.1 bouyer #endif
1179 1.1 bouyer return;
1180 1.1 bouyer }
1181 1.1 bouyer /* Grab a paquet for output */
1182 1.1 bouyer IF_DEQUEUE(&ifp->if_snd, mb_head);
1183 1.1 bouyer if (mb_head == NULL) {
1184 1.1 bouyer #ifdef TLDEBUG_TX
1185 1.1 bouyer printf("tl_ifstart: nothing to send\n");
1186 1.1 bouyer #endif
1187 1.1 bouyer return;
1188 1.1 bouyer }
1189 1.1 bouyer Tx = sc->Free_Tx;
1190 1.1 bouyer sc->Free_Tx = Tx->next;
1191 1.1 bouyer /*
1192 1.1 bouyer * Go through each of the mbufs in the chain and initialize
1193 1.1 bouyer * the transmit list descriptors with the physical address
1194 1.1 bouyer * and size of the mbuf.
1195 1.1 bouyer */
1196 1.1 bouyer tbdinit:
1197 1.1 bouyer bzero(Tx, sizeof(struct Tx_list));
1198 1.1 bouyer Tx->m = mb_head;
1199 1.1 bouyer size = 0;
1200 1.1 bouyer for (m = mb_head, segment = 0; m != NULL ; m = m->m_next) {
1201 1.1 bouyer if (m->m_len != 0) {
1202 1.1 bouyer if (segment == TL_NSEG)
1203 1.1 bouyer break;
1204 1.1 bouyer size += m->m_len;
1205 1.1 bouyer Tx->hw_list.seg[segment].data_addr =
1206 1.1 bouyer vtophys(mtod(m, vm_offset_t));
1207 1.1 bouyer Tx->hw_list.seg[segment].data_count = m->m_len;
1208 1.1 bouyer segment++;
1209 1.1 bouyer }
1210 1.1 bouyer }
1211 1.1 bouyer if (m != NULL || (size < ETHER_MIN_TX && segment == TL_NSEG)) {
1212 1.1 bouyer /*
1213 1.1 bouyer * We ran out of segments, or we will. We have to recopy this mbuf
1214 1.1 bouyer * chain first.
1215 1.1 bouyer */
1216 1.1 bouyer struct mbuf *mn;
1217 1.1 bouyer #ifdef TLDEBUG_TX
1218 1.1 bouyer printf("tl_ifstart: need to copy mbuf\n");
1219 1.1 bouyer #endif
1220 1.1 bouyer #ifdef TL_PRIV_STATS
1221 1.1 bouyer sc->oerr_mcopy++;
1222 1.1 bouyer #endif
1223 1.1 bouyer MGETHDR(mn, M_DONTWAIT, MT_DATA);
1224 1.1 bouyer if (mn == NULL) {
1225 1.1 bouyer m_freem(mb_head);
1226 1.1 bouyer goto bad;
1227 1.1 bouyer }
1228 1.1 bouyer if (mb_head->m_pkthdr.len > MHLEN) {
1229 1.1 bouyer MCLGET(mn, M_DONTWAIT);
1230 1.1 bouyer if ((mn->m_flags & M_EXT) == 0) {
1231 1.1 bouyer m_freem(mn);
1232 1.1 bouyer m_freem(mb_head);
1233 1.1 bouyer goto bad;
1234 1.1 bouyer }
1235 1.1 bouyer }
1236 1.1 bouyer m_copydata(mb_head, 0, mb_head->m_pkthdr.len,
1237 1.1 bouyer mtod(mn, caddr_t));
1238 1.1 bouyer mn->m_pkthdr.len = mn->m_len = mb_head->m_pkthdr.len;
1239 1.1 bouyer m_freem(mb_head);
1240 1.1 bouyer mb_head = mn;
1241 1.1 bouyer goto tbdinit;
1242 1.1 bouyer }
1243 1.1 bouyer /* We are at end of mbuf chain. check the size and
1244 1.1 bouyer * see if it needs to be extended
1245 1.1 bouyer */
1246 1.1 bouyer if (size < ETHER_MIN_TX) {
1247 1.1 bouyer #ifdef DIAGNOSTIC
1248 1.1 bouyer if (segment >= TL_NSEG) {
1249 1.1 bouyer panic("tl_ifstart: to much segmets (%d)\n", segment);
1250 1.1 bouyer }
1251 1.1 bouyer #endif
1252 1.1 bouyer /*
1253 1.1 bouyer * add the nullbuf in the seg
1254 1.1 bouyer */
1255 1.1 bouyer Tx->hw_list.seg[segment].data_count =
1256 1.1 bouyer ETHER_MIN_TX - size;
1257 1.1 bouyer Tx->hw_list.seg[segment].data_addr =
1258 1.1 bouyer vtophys(nullbuf);
1259 1.1 bouyer size = ETHER_MIN_TX;
1260 1.1 bouyer segment++;
1261 1.1 bouyer }
1262 1.1 bouyer /* The list is done, finish the list init */
1263 1.1 bouyer Tx->hw_list.seg[segment-1].data_count |=
1264 1.1 bouyer TL_LAST_SEG;
1265 1.1 bouyer Tx->hw_list.stat = (size << 16) | 0x3000;
1266 1.1 bouyer #ifdef TLDEBUG_TX
1267 1.1 bouyer printf("%s: sending, Tx : stat = 0x%x\n", sc->sc_dev.dv_xname,
1268 1.1 bouyer Tx->hw_list.stat);
1269 1.1 bouyer #if 0
1270 1.1 bouyer for(segment = 0; segment < TL_NSEG; segment++) {
1271 1.1 bouyer printf(" seg %d addr 0x%x len 0x%x\n",
1272 1.1 bouyer segment,
1273 1.1 bouyer Tx->hw_list.seg[segment].data_addr,
1274 1.1 bouyer Tx->hw_list.seg[segment].data_count);
1275 1.1 bouyer }
1276 1.1 bouyer #endif
1277 1.1 bouyer #endif
1278 1.1 bouyer sc->opkt++;
1279 1.1 bouyer if (sc->active_Tx == NULL) {
1280 1.1 bouyer sc->active_Tx = sc->last_Tx = Tx;
1281 1.1 bouyer #ifdef TLDEBUG_TX
1282 1.1 bouyer printf("%s: Tx GO, addr=0x%x\n", sc->sc_dev.dv_xname,
1283 1.1 bouyer vtophys(&Tx->hw_list));
1284 1.1 bouyer #endif
1285 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CH_PARM, vtophys(&Tx->hw_list));
1286 1.1 bouyer TL_HR_WRITE(sc, TL_HOST_CMD, HOST_CMD_GO);
1287 1.1 bouyer } else {
1288 1.1 bouyer #ifdef TLDEBUG_TX
1289 1.1 bouyer printf("%s: Tx addr=0x%x queued\n", sc->sc_dev.dv_xname,
1290 1.1 bouyer vtophys(&Tx->hw_list));
1291 1.1 bouyer #endif
1292 1.1 bouyer sc->last_Tx->hw_list.fwd = vtophys(&Tx->hw_list);
1293 1.1 bouyer sc->last_Tx->next = Tx;
1294 1.1 bouyer sc->last_Tx = Tx;
1295 1.1 bouyer #ifdef DIAGNOSTIC
1296 1.1 bouyer if (sc->last_Tx->hw_list.fwd & 0x7)
1297 1.1 bouyer printf("%s: physical addr 0x%x of list not properly aligned\n",
1298 1.1 bouyer sc->sc_dev.dv_xname, sc->last_Rx->hw_list.fwd);
1299 1.1 bouyer #endif
1300 1.1 bouyer }
1301 1.1 bouyer #if NBPFILTER > 0
1302 1.1 bouyer /* Pass packet to bpf if there is a listener */
1303 1.1 bouyer if (ifp->if_bpf)
1304 1.1 bouyer bpf_mtap(ifp->if_bpf, mb_head);
1305 1.1 bouyer #endif
1306 1.1 bouyer /* Set a 5 second timer just in case we don't hear from the card again. */
1307 1.1 bouyer ifp->if_timer = 5;
1308 1.1 bouyer
1309 1.1 bouyer goto txloop;
1310 1.1 bouyer bad:
1311 1.1 bouyer #ifdef TLDEBUG
1312 1.1 bouyer printf("tl_ifstart: Out of mbuf, Tx pkt lost\n");
1313 1.1 bouyer #endif
1314 1.1 bouyer Tx->next = sc->Free_Tx;
1315 1.1 bouyer sc->Free_Tx = Tx;
1316 1.1 bouyer return;
1317 1.1 bouyer }
1318 1.1 bouyer
1319 1.1 bouyer static void
1320 1.1 bouyer tl_ifwatchdog(ifp)
1321 1.1 bouyer struct ifnet *ifp;
1322 1.1 bouyer {
1323 1.1 bouyer tl_softc_t *sc = ifp->if_softc;
1324 1.1 bouyer
1325 1.1 bouyer if ((ifp->if_flags & IFF_RUNNING) == 0)
1326 1.1 bouyer return;
1327 1.1 bouyer printf("%s: device timeout\n", sc->sc_dev.dv_xname);
1328 1.1 bouyer ifp->if_oerrors++;
1329 1.1 bouyer tl_init(sc);
1330 1.1 bouyer }
1331 1.1 bouyer
1332 1.1 bouyer static int
1333 1.1 bouyer tl_mediachange(ifp)
1334 1.1 bouyer struct ifnet *ifp;
1335 1.1 bouyer {
1336 1.1 bouyer
1337 1.1 bouyer tl_softc_t *sc = ifp->if_softc;
1338 1.1 bouyer int err;
1339 1.1 bouyer u_int32_t reg;
1340 1.1 bouyer int oldmedia;
1341 1.1 bouyer #ifdef TLDEBUG
1342 1.1 bouyer printf("tl_mediachange, media %x\n", sc->tl_ifmedia.ifm_media);
1343 1.1 bouyer #endif
1344 1.1 bouyer oldmedia = sc->mii.mii_media_active;
1345 1.1 bouyer sc->mii.mii_media_active = sc->tl_ifmedia.ifm_media;
1346 1.1 bouyer if ((err = mii_mediachg(&sc->mii)) != 0)
1347 1.1 bouyer sc->mii.mii_media_active = oldmedia;
1348 1.1 bouyer reg = tl_intreg_read_byte(sc, TL_INT_NET + TL_INT_NetCmd);
1349 1.1 bouyer if (sc->mii.mii_media_active & IFM_FDX)
1350 1.1 bouyer reg |= TL_NETCOMMAND_DUPLEX;
1351 1.1 bouyer else
1352 1.1 bouyer reg &= ~TL_NETCOMMAND_DUPLEX;
1353 1.1 bouyer tl_intreg_write_byte(sc, TL_INT_NET + TL_INT_NetCmd, reg);
1354 1.1 bouyer return err;
1355 1.1 bouyer }
1356 1.1 bouyer
1357 1.1 bouyer static void
1358 1.1 bouyer tl_mediastatus(ifp, ifmr)
1359 1.1 bouyer struct ifnet *ifp;
1360 1.1 bouyer struct ifmediareq *ifmr;
1361 1.1 bouyer {
1362 1.1 bouyer tl_softc_t *sc = ifp->if_softc;
1363 1.1 bouyer if (IFM_SUBTYPE(sc->mii.mii_media_active) == IFM_10_2 ||
1364 1.1 bouyer IFM_SUBTYPE(sc->mii.mii_media_active) == IFM_10_5)
1365 1.1 bouyer if (sc->tl_flags & TL_IFACT)
1366 1.1 bouyer sc->mii.mii_media_status = IFM_AVALID | IFM_ACTIVE;
1367 1.1 bouyer else
1368 1.1 bouyer sc->mii.mii_media_status = IFM_AVALID;
1369 1.1 bouyer else
1370 1.1 bouyer mii_pollstat(&sc->mii);
1371 1.1 bouyer
1372 1.1 bouyer ifmr->ifm_active = sc->mii.mii_media_active;
1373 1.1 bouyer ifmr->ifm_status = sc->mii.mii_media_status;
1374 1.1 bouyer }
1375 1.1 bouyer
1376 1.1 bouyer static int tl_add_RxBuff(Rx, oldm)
1377 1.1 bouyer struct Rx_list *Rx;
1378 1.1 bouyer struct mbuf *oldm;
1379 1.1 bouyer {
1380 1.1 bouyer struct mbuf *m;
1381 1.1 bouyer
1382 1.1 bouyer MGETHDR(m, M_DONTWAIT, MT_DATA);
1383 1.1 bouyer if (m != NULL) {
1384 1.1 bouyer MCLGET(m, M_DONTWAIT);
1385 1.1 bouyer if ((m->m_flags & M_EXT) == 0) {
1386 1.1 bouyer m_freem(m);
1387 1.1 bouyer if (oldm == NULL)
1388 1.1 bouyer return 0;
1389 1.1 bouyer m = oldm;
1390 1.1 bouyer m->m_data = m->m_ext.ext_buf;
1391 1.1 bouyer }
1392 1.1 bouyer } else {
1393 1.1 bouyer if (oldm == NULL)
1394 1.1 bouyer return 0;
1395 1.1 bouyer m = oldm;
1396 1.1 bouyer m->m_data = m->m_ext.ext_buf;
1397 1.1 bouyer }
1398 1.1 bouyer /*
1399 1.1 bouyer * Move the data pointer up so that the incoming data packet
1400 1.1 bouyer * will be 32-bit aligned.
1401 1.1 bouyer */
1402 1.1 bouyer m->m_data += 2;
1403 1.1 bouyer
1404 1.1 bouyer /* (re)init the Rx_list struct */
1405 1.1 bouyer
1406 1.1 bouyer Rx->m = m;
1407 1.1 bouyer Rx->hw_list.stat = ((MCLBYTES -2) << 16) | 0x3000;
1408 1.1 bouyer Rx->hw_list.seg.data_count = (MCLBYTES -2);
1409 1.1 bouyer Rx->hw_list.seg.data_addr = vtophys(m->m_data);
1410 1.1 bouyer return (m != oldm);
1411 1.1 bouyer }
1412 1.1 bouyer
1413 1.1 bouyer static void tl_ticks(v)
1414 1.1 bouyer void *v;
1415 1.1 bouyer {
1416 1.1 bouyer tl_softc_t *sc = v;
1417 1.1 bouyer
1418 1.1 bouyer tl_read_stats(sc);
1419 1.1 bouyer if (sc->opkt > 0) {
1420 1.1 bouyer if (sc->oerr_exesscoll > sc->opkt / 100) { /* exess collisions */
1421 1.1 bouyer if (sc->tl_flags & TL_IFACT) /* only print once */
1422 1.1 bouyer printf("%s: no carrier\n", sc->sc_dev.dv_xname);
1423 1.1 bouyer sc->tl_flags &= ~TL_IFACT;
1424 1.1 bouyer } else
1425 1.1 bouyer sc->tl_flags |= TL_IFACT;
1426 1.1 bouyer sc->oerr_exesscoll = sc->opkt = 0;
1427 1.1 bouyer sc->tl_lasttx = 0;
1428 1.1 bouyer } else {
1429 1.1 bouyer sc->tl_lasttx++;
1430 1.1 bouyer if (sc->tl_lasttx >= TL_IDLETIME) {
1431 1.1 bouyer /*
1432 1.1 bouyer * No TX activity in the last TL_IDLETIME seconds.
1433 1.1 bouyer * sends a LLC Class1 TEST pkt
1434 1.1 bouyer */
1435 1.1 bouyer struct mbuf *m;
1436 1.1 bouyer int s;
1437 1.1 bouyer MGETHDR(m, M_DONTWAIT, MT_DATA);
1438 1.1 bouyer if (m != NULL) {
1439 1.1 bouyer #ifdef TLDEBUG
1440 1.1 bouyer printf("tl_ticks: sending LLC test pkt\n");
1441 1.1 bouyer #endif
1442 1.1 bouyer bcopy(sc->tl_enaddr,
1443 1.1 bouyer mtod(m, struct ether_header *)->ether_dhost, 6);
1444 1.1 bouyer bcopy(sc->tl_enaddr,
1445 1.1 bouyer mtod(m, struct ether_header *)->ether_shost, 6);
1446 1.1 bouyer mtod(m, struct ether_header *)->ether_type = htons(3);
1447 1.1 bouyer mtod(m, unsigned char *)[14] = 0;
1448 1.1 bouyer mtod(m, unsigned char *)[15] = 0;
1449 1.1 bouyer mtod(m, unsigned char *)[16] = 0xE3;
1450 1.1 bouyer /* LLC Class1 TEST (no poll) */
1451 1.1 bouyer m->m_len = m->m_pkthdr.len = sizeof(struct ether_header) + 3;
1452 1.1 bouyer s = splnet();
1453 1.1 bouyer IF_PREPEND(&sc->tl_if.if_snd, m);
1454 1.1 bouyer tl_ifstart(&sc->tl_if);
1455 1.1 bouyer splx(s);
1456 1.1 bouyer }
1457 1.1 bouyer }
1458 1.1 bouyer }
1459 1.1 bouyer
1460 1.1 bouyer /* read statistics every seconds */
1461 1.1 bouyer timeout(tl_ticks, v, hz);
1462 1.1 bouyer }
1463 1.1 bouyer
1464 1.1 bouyer static void
1465 1.1 bouyer tl_read_stats(sc)
1466 1.1 bouyer tl_softc_t *sc;
1467 1.1 bouyer {
1468 1.1 bouyer u_int32_t reg;
1469 1.1 bouyer int ierr_overr;
1470 1.1 bouyer int ierr_code;
1471 1.1 bouyer int ierr_crc;
1472 1.1 bouyer int oerr_underr;
1473 1.1 bouyer int oerr_deffered;
1474 1.1 bouyer int oerr_coll;
1475 1.1 bouyer int oerr_multicoll;
1476 1.1 bouyer int oerr_exesscoll;
1477 1.1 bouyer int oerr_latecoll;
1478 1.1 bouyer int oerr_carrloss;
1479 1.1 bouyer struct ifnet *ifp = &sc->tl_if;
1480 1.1 bouyer
1481 1.1 bouyer reg = tl_intreg_read(sc, TL_INT_STATS_TX);
1482 1.1 bouyer ifp->if_opackets += reg & 0x00ffffff;
1483 1.1 bouyer oerr_underr = reg >> 24;
1484 1.1 bouyer
1485 1.1 bouyer reg = tl_intreg_read(sc, TL_INT_STATS_RX);
1486 1.1 bouyer ifp->if_ipackets += reg & 0x00ffffff;
1487 1.1 bouyer ierr_overr = reg >> 24;
1488 1.1 bouyer
1489 1.1 bouyer reg = tl_intreg_read(sc, TL_INT_STATS_FERR);
1490 1.1 bouyer ierr_crc = (reg & TL_FERR_CRC) >> 16;
1491 1.1 bouyer ierr_code = (reg & TL_FERR_CODE) >> 24;
1492 1.1 bouyer oerr_deffered = (reg & TL_FERR_DEF);
1493 1.1 bouyer
1494 1.1 bouyer reg = tl_intreg_read(sc, TL_INT_STATS_COLL);
1495 1.1 bouyer oerr_multicoll = (reg & TL_COL_MULTI);
1496 1.1 bouyer oerr_coll = (reg & TL_COL_SINGLE) >> 16;
1497 1.1 bouyer
1498 1.1 bouyer reg = tl_intreg_read(sc, TL_INT_LERR);
1499 1.1 bouyer oerr_exesscoll = (reg & TL_LERR_ECOLL);
1500 1.1 bouyer oerr_latecoll = (reg & TL_LERR_LCOLL) >> 8;
1501 1.1 bouyer oerr_carrloss = (reg & TL_LERR_CL) >> 16;
1502 1.1 bouyer
1503 1.1 bouyer
1504 1.1 bouyer sc->stats_exesscoll += oerr_exesscoll;
1505 1.1 bouyer ifp->if_oerrors += oerr_underr + oerr_exesscoll + oerr_latecoll +
1506 1.1 bouyer oerr_carrloss;
1507 1.1 bouyer ifp->if_collisions += oerr_coll + oerr_multicoll;
1508 1.1 bouyer ifp->if_ierrors += ierr_overr + ierr_code + ierr_crc;
1509 1.1 bouyer
1510 1.1 bouyer if (ierr_overr)
1511 1.1 bouyer printf("%s: receiver ring buffer overrun\n", sc->sc_dev.dv_xname);
1512 1.1 bouyer if (oerr_underr)
1513 1.1 bouyer printf("%s: transmit buffer underrun\n", sc->sc_dev.dv_xname);
1514 1.1 bouyer #ifdef TL_PRIV_STATS
1515 1.1 bouyer sc->ierr_overr += ierr_overr;
1516 1.1 bouyer sc->ierr_code += ierr_code;
1517 1.1 bouyer sc->ierr_crc += ierr_crc;
1518 1.1 bouyer sc->oerr_underr += oerr_underr;
1519 1.1 bouyer sc->oerr_deffered += oerr_deffered;
1520 1.1 bouyer sc->oerr_coll += oerr_coll;
1521 1.1 bouyer sc->oerr_multicoll += oerr_multicoll;
1522 1.1 bouyer sc->oerr_exesscoll += oerr_exesscoll;
1523 1.1 bouyer sc->oerr_latecoll += oerr_latecoll;
1524 1.1 bouyer sc->oerr_carrloss += oerr_carrloss;
1525 1.1 bouyer #endif
1526 1.1 bouyer }
1527 1.1 bouyer
1528 1.1 bouyer static void tl_addr_filter(sc)
1529 1.1 bouyer tl_softc_t *sc;
1530 1.1 bouyer {
1531 1.1 bouyer struct ether_multistep step;
1532 1.1 bouyer struct ether_multi *enm;
1533 1.1 bouyer u_int32_t hash[2] = {0, 0};
1534 1.1 bouyer int i;
1535 1.1 bouyer
1536 1.1 bouyer sc->tl_if.if_flags &= ~IFF_ALLMULTI;
1537 1.1 bouyer ETHER_FIRST_MULTI(step, &sc->tl_ec, enm);
1538 1.1 bouyer while (enm != NULL) {
1539 1.1 bouyer #ifdef TLDEBUG
1540 1.1 bouyer printf("tl_addr_filter: addrs %s %s\n", ether_sprintf(enm->enm_addrlo), ether_sprintf(enm->enm_addrhi));
1541 1.1 bouyer #endif
1542 1.1 bouyer if (memcmp(enm->enm_addrlo, enm->enm_addrhi, 6) == 0) {
1543 1.1 bouyer i = tl_multicast_hash(enm->enm_addrlo);
1544 1.1 bouyer hash[i/32] |= 1 << (i%32);
1545 1.1 bouyer } else {
1546 1.1 bouyer hash[0] = hash[1] = 0xffffffff;
1547 1.1 bouyer sc->tl_if.if_flags |= IFF_ALLMULTI;
1548 1.1 bouyer break;
1549 1.1 bouyer }
1550 1.1 bouyer ETHER_NEXT_MULTI(step, enm);
1551 1.1 bouyer }
1552 1.1 bouyer #ifdef TLDEBUG
1553 1.1 bouyer printf("tl_addr_filer: hash1 %x has2 %x\n", hash[0], hash[1]);
1554 1.1 bouyer #endif
1555 1.1 bouyer tl_intreg_write(sc, TL_INT_HASH1, hash[0]);
1556 1.1 bouyer tl_intreg_write(sc, TL_INT_HASH2, hash[1]);
1557 1.1 bouyer }
1558 1.1 bouyer
1559 1.1 bouyer static int tl_multicast_hash(a)
1560 1.1 bouyer u_int8_t *a;
1561 1.1 bouyer {
1562 1.1 bouyer int hash;
1563 1.1 bouyer
1564 1.1 bouyer #define DA(addr,bit) (addr[5 - (bit/8)] & (1 << bit%8))
1565 1.1 bouyer #define xor8(a,b,c,d,e,f,g,h) (((a != 0) + (b != 0) + (c != 0) + (d != 0) + (e != 0) + (f != 0) + (g != 0) + (h != 0)) & 1)
1566 1.1 bouyer
1567 1.1 bouyer hash = xor8( DA(a,0), DA(a, 6), DA(a,12), DA(a,18), DA(a,24), DA(a,30),
1568 1.1 bouyer DA(a,36), DA(a,42));
1569 1.1 bouyer hash |= xor8( DA(a,1), DA(a, 7), DA(a,13), DA(a,19), DA(a,25), DA(a,31),
1570 1.1 bouyer DA(a,37), DA(a,43)) << 1;
1571 1.1 bouyer hash |= xor8( DA(a,2), DA(a, 8), DA(a,14), DA(a,20), DA(a,26), DA(a,32),
1572 1.1 bouyer DA(a,38), DA(a,44)) << 2;
1573 1.1 bouyer hash |= xor8( DA(a,3), DA(a, 9), DA(a,15), DA(a,21), DA(a,27), DA(a,33),
1574 1.1 bouyer DA(a,39), DA(a,45)) << 3;
1575 1.1 bouyer hash |= xor8( DA(a,4), DA(a,10), DA(a,16), DA(a,22), DA(a,28), DA(a,34),
1576 1.1 bouyer DA(a,40), DA(a,46)) << 4;
1577 1.1 bouyer hash |= xor8( DA(a,5), DA(a,11), DA(a,17), DA(a,23), DA(a,29), DA(a,35),
1578 1.1 bouyer DA(a,41), DA(a,47)) << 5;
1579 1.1 bouyer
1580 1.1 bouyer return hash;
1581 1.1 bouyer }
1582 1.1 bouyer
1583 1.1 bouyer #if defined(TLDEBUG_RX)
1584 1.1 bouyer void ether_printheader(eh)
1585 1.1 bouyer struct ether_header *eh;
1586 1.1 bouyer {
1587 1.1 bouyer u_char *c = (char*)eh;
1588 1.1 bouyer int i;
1589 1.1 bouyer for (i=0; i<sizeof(struct ether_header); i++)
1590 1.1 bouyer printf("%x ", (u_int)c[i]);
1591 1.1 bouyer printf("\n");
1592 1.1 bouyer }
1593 1.1 bouyer #endif
1594