1 /* $NetBSD: if_fxp_cardbus.c,v 1.53 2022/09/25 17:33:19 thorpej Exp $ */
2
3 /*
4 * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Johan Danielsson.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*
33 * CardBus front-end for the Intel i82557 family of Ethernet chips.
34 */
35
36 #include <sys/cdefs.h>
37 __KERNEL_RCSID(0, "$NetBSD: if_fxp_cardbus.c,v 1.53 2022/09/25 17:33:19 thorpej Exp $");
38
39 #include "opt_inet.h"
40
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/mbuf.h>
44 #include <sys/kernel.h>
45 #include <sys/socket.h>
46 #include <sys/ioctl.h>
47 #include <sys/errno.h>
48 #include <sys/device.h>
49
50 #include <net/if.h>
51 #include <net/if_dl.h>
52 #include <net/if_media.h>
53 #include <net/if_ether.h>
54
55 #include <machine/endian.h>
56
57 #ifdef INET
58 #include <netinet/in.h>
59 #include <netinet/if_inarp.h>
60 #endif
61
62
63 #include <sys/bus.h>
64 #include <sys/intr.h>
65
66 #include <dev/mii/miivar.h>
67
68 #include <dev/ic/i82557reg.h>
69 #include <dev/ic/i82557var.h>
70
71 #include <dev/pci/pcivar.h>
72 #include <dev/pci/pcireg.h>
73 #include <dev/pci/pcidevs.h>
74
75 #include <dev/cardbus/cardbusvar.h>
76 #include <dev/pci/pcidevs.h>
77
78 static int fxp_cardbus_match(device_t, cfdata_t, void *);
79 static void fxp_cardbus_attach(device_t, device_t, void *);
80 static int fxp_cardbus_detach(device_t, int);
81 static void fxp_cardbus_setup(struct fxp_softc *);
82 static int fxp_cardbus_enable(struct fxp_softc *);
83 static void fxp_cardbus_disable(struct fxp_softc *);
84
85 struct fxp_cardbus_softc {
86 struct fxp_softc sc;
87 cardbus_devfunc_t ct;
88 pcitag_t tag;
89 pcireg_t base0_reg;
90 pcireg_t base1_reg;
91 };
92
93 CFATTACH_DECL3_NEW(fxp_cardbus, sizeof(struct fxp_cardbus_softc),
94 fxp_cardbus_match, fxp_cardbus_attach, fxp_cardbus_detach, fxp_activate,
95 NULL, null_childdetached, DVF_DETACH_SHUTDOWN);
96
97 #ifdef CBB_DEBUG
98 #define DPRINTF(X) printf X
99 #else
100 #define DPRINTF(X)
101 #endif
102
103 static int
fxp_cardbus_match(device_t parent,cfdata_t match,void * aux)104 fxp_cardbus_match(device_t parent, cfdata_t match, void *aux)
105 {
106 struct cardbus_attach_args *ca = aux;
107
108 if (PCI_VENDOR(ca->ca_id) == PCI_VENDOR_INTEL &&
109 PCI_PRODUCT(ca->ca_id) == PCI_PRODUCT_INTEL_8255X)
110 return (1);
111
112 return (0);
113 }
114
115 static void
fxp_cardbus_attach(device_t parent,device_t self,void * aux)116 fxp_cardbus_attach(device_t parent, device_t self, void *aux)
117 {
118 struct fxp_cardbus_softc *csc = device_private(self);
119 struct fxp_softc *sc = &csc->sc;
120 struct cardbus_attach_args *ca = aux;
121 bus_space_tag_t iot, memt;
122 bus_space_handle_t ioh, memh;
123
124 bus_addr_t adr;
125
126 sc->sc_dev = self;
127 csc->ct = ca->ca_ct;
128 csc->tag = ca->ca_tag;
129
130 /*
131 * Map control/status registers.
132 */
133 if (Cardbus_mapreg_map(csc->ct, PCI_BAR1,
134 PCI_MAPREG_TYPE_IO, 0, &iot, &ioh, &adr, &sc->sc_size) == 0) {
135 csc->base1_reg = adr | 1;
136 sc->sc_st = iot;
137 sc->sc_sh = ioh;
138 } else if (Cardbus_mapreg_map(csc->ct, PCI_BAR0,
139 PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT,
140 0, &memt, &memh, &adr, &sc->sc_size) == 0) {
141 csc->base0_reg = adr;
142 sc->sc_st = memt;
143 sc->sc_sh = memh;
144 } else
145 panic("%s: failed to allocate mem and io space", __func__);
146
147 if (ca->ca_cis.cis1_info[0] && ca->ca_cis.cis1_info[1])
148 printf(": %s %s\n", ca->ca_cis.cis1_info[0],
149 ca->ca_cis.cis1_info[1]);
150 else
151 printf("\n");
152
153 sc->sc_rev = PCI_REVISION(ca->ca_class);
154 if (sc->sc_rev >= FXP_REV_82558_A4)
155 sc->sc_flags |= FXPF_FC|FXPF_EXT_TXCB;
156 if (sc->sc_rev >= FXP_REV_82559_A0)
157 sc->sc_flags |= FXPF_82559_RXCSUM;
158 if (sc->sc_rev >= FXP_REV_82550) {
159 sc->sc_flags &= ~FXPF_82559_RXCSUM;
160 sc->sc_flags |= FXPF_EXT_RFA;
161 }
162
163 sc->sc_dmat = ca->ca_dmat;
164 sc->sc_enable = fxp_cardbus_enable;
165 sc->sc_disable = fxp_cardbus_disable;
166 sc->sc_enabled = 0;
167
168 fxp_enable(sc);
169 fxp_attach(sc);
170 fxp_disable(sc);
171
172 if (pmf_device_register(self, NULL, NULL))
173 pmf_class_network_register(self, &sc->sc_ethercom.ec_if);
174 else
175 aprint_error_dev(self, "couldn't establish power handler\n");
176 }
177
178 static void
fxp_cardbus_setup(struct fxp_softc * sc)179 fxp_cardbus_setup(struct fxp_softc * sc)
180 {
181 struct fxp_cardbus_softc *csc = (struct fxp_cardbus_softc *)sc;
182 pcireg_t command;
183
184 pcitag_t tag = csc->tag;
185
186 command = Cardbus_conf_read(csc->ct, tag, PCI_COMMAND_STATUS_REG);
187 if (csc->base0_reg) {
188 Cardbus_conf_write(csc->ct, tag,
189 PCI_BAR0, csc->base0_reg);
190 command |= PCI_COMMAND_MEM_ENABLE | PCI_COMMAND_MASTER_ENABLE;
191 } else if (csc->base1_reg) {
192 Cardbus_conf_write(csc->ct, tag,
193 PCI_BAR1, csc->base1_reg);
194 command |= PCI_COMMAND_IO_ENABLE | PCI_COMMAND_MASTER_ENABLE;
195 }
196
197 /* enable the card */
198 Cardbus_conf_write(csc->ct, tag, PCI_COMMAND_STATUS_REG, command);
199 }
200
201 static int
fxp_cardbus_enable(struct fxp_softc * sc)202 fxp_cardbus_enable(struct fxp_softc * sc)
203 {
204 struct fxp_cardbus_softc *csc = (struct fxp_cardbus_softc *)sc;
205 cardbus_devfunc_t ct = csc->ct;
206
207 Cardbus_function_enable(csc->ct);
208
209 fxp_cardbus_setup(sc);
210
211 /* Map and establish the interrupt. */
212
213 sc->sc_ih = Cardbus_intr_establish(ct, IPL_NET, fxp_intr, sc);
214 if (NULL == sc->sc_ih) {
215 aprint_error_dev(sc->sc_dev, "couldn't establish interrupt\n");
216 return 1;
217 }
218
219 return 0;
220 }
221
222 static void
fxp_cardbus_disable(struct fxp_softc * sc)223 fxp_cardbus_disable(struct fxp_softc * sc)
224 {
225 struct fxp_cardbus_softc *csc = (struct fxp_cardbus_softc *)sc;
226 cardbus_devfunc_t ct = csc->ct;
227
228 /* Remove interrupt handler. */
229 Cardbus_intr_disestablish(ct, sc->sc_ih);
230
231 Cardbus_function_disable(csc->ct);
232 }
233
234 static int
fxp_cardbus_detach(device_t self,int flags)235 fxp_cardbus_detach(device_t self, int flags)
236 {
237 struct fxp_cardbus_softc *csc = device_private(self);
238 struct fxp_softc *sc = &csc->sc;
239 struct cardbus_devfunc *ct = csc->ct;
240 int rv, reg;
241
242 #ifdef DIAGNOSTIC
243 if (ct == NULL)
244 panic("%s: data structure lacks", device_xname(self));
245 #endif
246
247 if ((rv = fxp_detach(sc, flags)) != 0)
248 return rv;
249 /*
250 * Unhook the interrupt handler.
251 */
252 Cardbus_intr_disestablish(ct, sc->sc_ih);
253
254 /*
255 * release bus space and close window
256 */
257 if (csc->base0_reg)
258 reg = PCI_BAR0;
259 else
260 reg = PCI_BAR1;
261 Cardbus_mapreg_unmap(ct, reg, sc->sc_st, sc->sc_sh, sc->sc_size);
262 return 0;
263 }
264