1 /* $NetBSD: if_hme_pci.c,v 1.24 2008/04/10 19:13:37 cegger Exp $ */ 2 3 /* 4 * Copyright (c) 2000 Matthew R. Green 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 25 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 /* 32 * PCI front-end device driver for the HME ethernet device. 33 */ 34 35 #include <sys/cdefs.h> 36 __KERNEL_RCSID(0, "$NetBSD: if_hme_pci.c,v 1.24 2008/04/10 19:13:37 cegger Exp $"); 37 38 #include <sys/param.h> 39 #include <sys/systm.h> 40 #include <sys/syslog.h> 41 #include <sys/device.h> 42 #include <sys/malloc.h> 43 #include <sys/socket.h> 44 45 #include <net/if.h> 46 #include <net/if_dl.h> 47 #include <net/if_ether.h> 48 #include <net/if_media.h> 49 50 #include <dev/mii/mii.h> 51 #include <dev/mii/miivar.h> 52 53 #include <sys/intr.h> 54 55 #include <dev/pci/pcivar.h> 56 #include <dev/pci/pcireg.h> 57 #include <dev/pci/pcidevs.h> 58 59 #include <dev/ic/hmevar.h> 60 #ifdef __sparc__ 61 #include <machine/promlib.h> 62 #endif 63 64 #ifndef HME_USE_LOCAL_MAC_ADDRESS 65 #ifdef __sparc__ 66 #define HME_USE_LOCAL_MAC_ADDRESS 0 /* use system-wide address */ 67 #else 68 #define HME_USE_LOCAL_MAC_ADDRESS 1 69 #endif 70 #endif 71 72 struct hme_pci_softc { 73 struct hme_softc hsc_hme; /* HME device */ 74 bus_space_tag_t hsc_memt; 75 bus_space_handle_t hsc_memh; 76 void *hsc_ih; 77 }; 78 79 int hmematch_pci(struct device *, struct cfdata *, void *); 80 void hmeattach_pci(struct device *, struct device *, void *); 81 82 CFATTACH_DECL(hme_pci, sizeof(struct hme_pci_softc), 83 hmematch_pci, hmeattach_pci, NULL, NULL); 84 85 int 86 hmematch_pci(struct device *parent, struct cfdata *cf, 87 void *aux) 88 { 89 struct pci_attach_args *pa = aux; 90 91 if (PCI_VENDOR(pa->pa_id) == PCI_VENDOR_SUN && 92 PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_SUN_HMENETWORK) 93 return (1); 94 95 return (0); 96 } 97 98 #if HME_USE_LOCAL_MAC_ADDRESS 99 static inline int 100 hmepromvalid(u_int8_t* buf) 101 { 102 return buf[0] == 0x18 && buf[1] == 0x00 && /* structure length */ 103 buf[2] == 0x00 && /* revision */ 104 (buf[3] == 0x00 || /* hme */ 105 buf[3] == 0x80) && /* qfe */ 106 buf[4] == PCI_SUBCLASS_NETWORK_ETHERNET && /* subclass code */ 107 buf[5] == PCI_CLASS_NETWORK; /* class code */ 108 } 109 110 static inline int 111 hmevpdoff(bus_space_tag_t romt, bus_space_handle_t romh, int vpdoff, int dev) 112 { 113 #define VPDLEN (3 + sizeof(struct pci_vpd) + ETHER_ADDR_LEN) 114 if (bus_space_read_1(romt, romh, vpdoff + VPDLEN) != 0x79 && 115 bus_space_read_1(romt, romh, vpdoff + 4 * VPDLEN) == 0x79) { 116 /* 117 * Use the Nth NA for the Nth HME on 118 * this SUNW,qfe. 119 */ 120 vpdoff += dev * VPDLEN; 121 } 122 return vpdoff; 123 } 124 #endif 125 126 void 127 hmeattach_pci(struct device *parent, struct device *self, void *aux) 128 { 129 struct pci_attach_args *pa = aux; 130 struct hme_pci_softc *hsc = (void *)self; 131 struct hme_softc *sc = &hsc->hsc_hme; 132 pci_intr_handle_t ih; 133 pcireg_t csr; 134 const char *intrstr; 135 int type; 136 #if HME_USE_LOCAL_MAC_ADDRESS 137 struct pci_attach_args ebus_pa; 138 pcireg_t ebus_cl, ebus_id; 139 u_int8_t *enaddr; 140 bus_space_tag_t romt; 141 bus_space_handle_t romh; 142 bus_size_t romsize; 143 u_int8_t buf[64]; 144 int dataoff, vpdoff; 145 struct pci_vpd *vpd; 146 static const u_int8_t promhdr[] = { 0x55, 0xaa }; 147 #define PROMHDR_PTR_DATA 0x18 148 static const u_int8_t promdat[] = { 149 0x50, 0x43, 0x49, 0x52, /* "PCIR" */ 150 PCI_VENDOR_SUN & 0xff, PCI_VENDOR_SUN >> 8, 151 PCI_PRODUCT_SUN_HMENETWORK & 0xff, 152 PCI_PRODUCT_SUN_HMENETWORK >> 8 153 }; 154 #define PROMDATA_PTR_VPD 0x08 155 #define PROMDATA_DATA2 0x0a 156 #endif /* HME_USE_LOCAL_MAC_ADDRESS */ 157 158 printf(": Sun Happy Meal Ethernet, rev. %d\n", 159 PCI_REVISION(pa->pa_class)); 160 161 /* 162 * enable io/memory-space accesses. this is kinda of gross; but 163 # the hme comes up with neither IO space enabled, or memory space. 164 */ 165 if (pa->pa_memt) 166 pa->pa_flags |= PCI_FLAGS_MEM_ENABLED; 167 if (pa->pa_iot) 168 pa->pa_flags |= PCI_FLAGS_IO_ENABLED; 169 csr = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG); 170 if (pa->pa_memt) { 171 type = PCI_MAPREG_TYPE_MEM; 172 csr |= PCI_COMMAND_MEM_ENABLE; 173 sc->sc_bustag = pa->pa_memt; 174 } else { 175 type = PCI_MAPREG_TYPE_IO; 176 csr |= PCI_COMMAND_IO_ENABLE; 177 sc->sc_bustag = pa->pa_iot; 178 } 179 pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG, 180 csr | PCI_COMMAND_MEM_ENABLE); 181 182 sc->sc_dmatag = pa->pa_dmat; 183 184 sc->sc_pci = 1; /* XXXXX should all be done in bus_dma. */ 185 /* 186 * Map five register banks: 187 * 188 * bank 0: HME SEB registers: +0x0000 189 * bank 1: HME ETX registers: +0x2000 190 * bank 2: HME ERX registers: +0x4000 191 * bank 3: HME MAC registers: +0x6000 192 * bank 4: HME MIF registers: +0x7000 193 * 194 */ 195 196 #define PCI_HME_BASEADDR 0x10 197 if (pci_mapreg_map(pa, PCI_HME_BASEADDR, type, 0, 198 &hsc->hsc_memt, &hsc->hsc_memh, NULL, NULL) != 0) 199 { 200 aprint_error_dev(&sc->sc_dev, "unable to map device registers\n"); 201 return; 202 } 203 sc->sc_seb = hsc->hsc_memh; 204 if (bus_space_subregion(hsc->hsc_memt, hsc->hsc_memh, 0x2000, 205 0x1000, &sc->sc_etx)) { 206 aprint_error_dev(&sc->sc_dev, "unable to subregion ETX registers\n"); 207 return; 208 } 209 if (bus_space_subregion(hsc->hsc_memt, hsc->hsc_memh, 0x4000, 210 0x1000, &sc->sc_erx)) { 211 aprint_error_dev(&sc->sc_dev, "unable to subregion ERX registers\n"); 212 return; 213 } 214 if (bus_space_subregion(hsc->hsc_memt, hsc->hsc_memh, 0x6000, 215 0x1000, &sc->sc_mac)) { 216 aprint_error_dev(&sc->sc_dev, "unable to subregion MAC registers\n"); 217 return; 218 } 219 if (bus_space_subregion(hsc->hsc_memt, hsc->hsc_memh, 0x7000, 220 0x1000, &sc->sc_mif)) { 221 aprint_error_dev(&sc->sc_dev, "unable to subregion MIF registers\n"); 222 return; 223 } 224 225 #if HME_USE_LOCAL_MAC_ADDRESS 226 /* 227 * Dig out VPD (vital product data) and acquire Ethernet address. 228 * The VPD of hme resides in the Boot PROM (PCI FCode) attached 229 * to the EBus interface. 230 */ 231 /* 232 * ``Writing FCode 3.x Programs'' (newer ones, dated 1997 and later) 233 * chapter 2 describes the data structure. 234 */ 235 236 enaddr = NULL; 237 238 /* get a PCI tag for the EBus bridge (function 0 of the same device) */ 239 ebus_pa = *pa; 240 ebus_pa.pa_tag = pci_make_tag(pa->pa_pc, pa->pa_bus, pa->pa_device, 0); 241 242 ebus_cl = pci_conf_read(ebus_pa.pa_pc, ebus_pa.pa_tag, PCI_CLASS_REG); 243 ebus_id = pci_conf_read(ebus_pa.pa_pc, ebus_pa.pa_tag, PCI_ID_REG); 244 245 #define PCI_EBUS2_BOOTROM 0x10 246 if (PCI_CLASS(ebus_cl) == PCI_CLASS_BRIDGE && 247 PCI_PRODUCT(ebus_id) == PCI_PRODUCT_SUN_EBUS && 248 pci_mapreg_map(&ebus_pa, PCI_EBUS2_BOOTROM, PCI_MAPREG_TYPE_MEM, 249 BUS_SPACE_MAP_CACHEABLE | BUS_SPACE_MAP_PREFETCHABLE, 250 &romt, &romh, 0, &romsize) == 0) { 251 252 /* read PCI Expansion PROM Header */ 253 bus_space_read_region_1(romt, romh, 0, buf, sizeof buf); 254 if (memcmp(buf, promhdr, sizeof promhdr) == 0 && 255 (dataoff = (buf[PROMHDR_PTR_DATA] | 256 (buf[PROMHDR_PTR_DATA + 1] << 8))) >= 0x1c) { 257 258 /* read PCI Expansion PROM Data */ 259 bus_space_read_region_1(romt, romh, dataoff, 260 buf, sizeof buf); 261 if (memcmp(buf, promdat, sizeof promdat) == 0 && 262 hmepromvalid(buf + PROMDATA_DATA2) && 263 (vpdoff = (buf[PROMDATA_PTR_VPD] | 264 (buf[PROMDATA_PTR_VPD + 1] << 8))) >= 0x1c) { 265 266 /* 267 * The VPD of hme is not in PCI 2.2 standard 268 * format. The length in the resource header 269 * is in big endian, and resources are not 270 * properly terminated (only one resource 271 * and no end tag). 272 */ 273 vpdoff = hmevpdoff(romt, romh, vpdoff, 274 pa->pa_device); 275 /* read PCI VPD */ 276 bus_space_read_region_1(romt, romh, 277 vpdoff, buf, sizeof buf); 278 vpd = (void *)(buf + 3); 279 if (PCI_VPDRES_ISLARGE(buf[0]) && 280 PCI_VPDRES_LARGE_NAME(buf[0]) 281 == PCI_VPDRES_TYPE_VPD && 282 /* buf[1] == 0 && buf[2] == 9 && */ /*len*/ 283 vpd->vpd_key0 == 0x4e /* N */ && 284 vpd->vpd_key1 == 0x41 /* A */ && 285 vpd->vpd_len == ETHER_ADDR_LEN) { 286 /* 287 * Ethernet address found 288 */ 289 enaddr = buf + 6; 290 } 291 } 292 } 293 bus_space_unmap(romt, romh, romsize); 294 } 295 296 if (enaddr) 297 memcpy(sc->sc_enaddr, enaddr, ETHER_ADDR_LEN); 298 else 299 #endif /* HME_USE_LOCAL_MAC_ADDRESS */ 300 #ifdef __sparc__ 301 prom_getether(PCITAG_NODE(pa->pa_tag), sc->sc_enaddr); 302 #else 303 printf("%s: no Ethernet address found\n", device_xname(&sc->sc_dev)); 304 #endif 305 306 /* 307 * Map and establish our interrupt. 308 */ 309 if (pci_intr_map(pa, &ih) != 0) { 310 aprint_error_dev(&sc->sc_dev, "unable to map interrupt\n"); 311 return; 312 } 313 intrstr = pci_intr_string(pa->pa_pc, ih); 314 hsc->hsc_ih = pci_intr_establish(pa->pa_pc, ih, IPL_NET, hme_intr, sc); 315 if (hsc->hsc_ih == NULL) { 316 aprint_error_dev(&sc->sc_dev, "unable to establish interrupt"); 317 if (intrstr != NULL) 318 printf(" at %s", intrstr); 319 printf("\n"); 320 return; 321 } 322 printf("%s: interrupting at %s\n", device_xname(&sc->sc_dev), intrstr); 323 324 sc->sc_burst = 16; /* XXX */ 325 326 /* Finish off the attach. */ 327 hme_config(sc); 328 } 329