if_cs_isa.c revision 1.19
1 /* $NetBSD: if_cs_isa.c,v 1.19 2007/10/19 12:00:17 ad Exp $ */ 2 3 /* 4 * Copyright 1997 5 * Digital Equipment Corporation. All rights reserved. 6 * 7 * This software is furnished under license and may be used and 8 * copied only in accordance with the following terms and conditions. 9 * Subject to these conditions, you may download, copy, install, 10 * use, modify and distribute this software in source and/or binary 11 * form. No title or ownership is transferred hereby. 12 * 13 * 1) Any source code used, modified or distributed must reproduce 14 * and retain this copyright notice and list of conditions as 15 * they appear in the source file. 16 * 17 * 2) No right is granted to use any trade name, trademark, or logo of 18 * Digital Equipment Corporation. Neither the "Digital Equipment 19 * Corporation" name nor any trademark or logo of Digital Equipment 20 * Corporation may be used to endorse or promote products derived 21 * from this software without the prior written permission of 22 * Digital Equipment Corporation. 23 * 24 * 3) This software is provided "AS-IS" and any express or implied 25 * warranties, including but not limited to, any implied warranties 26 * of merchantability, fitness for a particular purpose, or 27 * non-infringement are disclaimed. In no event shall DIGITAL be 28 * liable for any damages whatsoever, and in particular, DIGITAL 29 * shall not be liable for special, indirect, consequential, or 30 * incidental damages or damages for lost profits, loss of 31 * revenue or loss of use, whether such damages arise in contract, 32 * negligence, tort, under statute, in equity, at law or otherwise, 33 * even if advised of the possibility of such damage. 34 */ 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: if_cs_isa.c,v 1.19 2007/10/19 12:00:17 ad Exp $"); 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/socket.h> 42 #include <sys/device.h> 43 44 #include "rnd.h" 45 #if NRND > 0 46 #include <sys/rnd.h> 47 #endif 48 49 #include <net/if.h> 50 #include <net/if_ether.h> 51 #include <net/if_media.h> 52 53 #include <sys/bus.h> 54 #include <sys/intr.h> 55 56 #include <dev/isa/isareg.h> 57 #include <dev/isa/isavar.h> 58 #include <dev/isa/isadmavar.h> 59 60 #include <dev/ic/cs89x0reg.h> 61 #include <dev/ic/cs89x0var.h> 62 #include <dev/isa/cs89x0isavar.h> 63 64 int cs_isa_probe(struct device *, struct cfdata *, void *); 65 void cs_isa_attach(struct device *, struct device *, void *); 66 67 CFATTACH_DECL(cs_isa, sizeof(struct cs_softc), 68 cs_isa_probe, cs_isa_attach, NULL, NULL); 69 70 int 71 cs_isa_probe(struct device *parent, struct cfdata *cf, 72 void *aux) 73 { 74 struct isa_attach_args *ia = aux; 75 bus_space_tag_t iot = ia->ia_iot; 76 bus_space_tag_t memt = ia->ia_memt; 77 bus_space_handle_t ioh, memh; 78 struct cs_softc sc; 79 int rv = 0, have_io = 0, have_mem = 0; 80 u_int16_t isa_cfg, isa_membase; 81 int maddr, irq; 82 83 if (ia->ia_nio < 1) 84 return (0); 85 if (ia->ia_nirq < 1) 86 return (0); 87 88 if (ISA_DIRECT_CONFIG(ia)) 89 return (0); 90 91 /* 92 * Disallow wildcarded I/O base. 93 */ 94 if (ia->ia_io[0].ir_addr == ISA_UNKNOWN_PORT) 95 return (0); 96 97 if (ia->ia_niomem > 0) 98 maddr = ia->ia_iomem[0].ir_addr; 99 else 100 maddr = ISA_UNKNOWN_IOMEM; 101 102 /* 103 * Map the I/O space. 104 */ 105 if (bus_space_map(ia->ia_iot, ia->ia_io[0].ir_addr, CS8900_IOSIZE, 106 0, &ioh)) 107 goto out; 108 have_io = 1; 109 110 memset(&sc, 0, sizeof sc); 111 sc.sc_iot = iot; 112 sc.sc_ioh = ioh; 113 /* Verify that it's a Crystal product. */ 114 if (CS_READ_PACKET_PAGE_IO(&sc, PKTPG_EISA_NUM) != 115 EISA_NUM_CRYSTAL) 116 goto out; 117 118 /* 119 * Verify that it's a supported chip. 120 */ 121 switch (CS_READ_PACKET_PAGE_IO(&sc, PKTPG_PRODUCT_ID) & 122 PROD_ID_MASK) { 123 case PROD_ID_CS8900: 124 #ifdef notyet 125 case PROD_ID_CS8920: 126 case PROD_ID_CS8920M: 127 #endif 128 break; 129 default: 130 /* invalid product ID */ 131 goto out; 132 } 133 134 /* 135 * If the IRQ or memory address were not specified, read the 136 * ISA_CFG EEPROM location. 137 */ 138 if (maddr == ISA_UNKNOWN_IOMEM || 139 ia->ia_irq[0].ir_irq == ISA_UNKNOWN_IRQ) { 140 if (cs_verify_eeprom(&sc) == CS_ERROR) { 141 printf("cs_isa_probe: EEPROM bad or missing\n"); 142 goto out; 143 } 144 if (cs_read_eeprom(&sc, EEPROM_ISA_CFG, &isa_cfg) 145 == CS_ERROR) { 146 printf("cs_isa_probe: unable to read ISA_CFG\n"); 147 goto out; 148 } 149 } 150 151 /* 152 * If the IRQ wasn't specified, get it from the EEPROM. 153 */ 154 if (ia->ia_irq[0].ir_irq == ISA_UNKNOWN_IRQ) { 155 irq = isa_cfg & ISA_CFG_IRQ_MASK; 156 if (irq == 3) 157 irq = 5; 158 else 159 irq += 10; 160 } else 161 irq = ia->ia_irq[0].ir_irq; 162 163 /* 164 * If the memory address wasn't specified, get it from the EEPROM. 165 */ 166 if (maddr == ISA_UNKNOWN_IOMEM) { 167 if ((isa_cfg & ISA_CFG_MEM_MODE) == 0) { 168 /* EEPROM says don't use memory mode. */ 169 goto out; 170 } 171 if (cs_read_eeprom(&sc, EEPROM_MEM_BASE, &isa_membase) 172 == CS_ERROR) { 173 printf("cs_isa_probe: unable to read MEM_BASE\n"); 174 goto out; 175 } 176 177 isa_membase &= MEM_BASE_MASK; 178 maddr = (int)isa_membase << 8; 179 } 180 181 /* 182 * We now have a valid mem address; attempt to map it. 183 */ 184 if (bus_space_map(ia->ia_memt, maddr, CS8900_MEMSIZE, 0, &memh)) { 185 /* Can't map it; fall back on i/o-only mode. */ 186 printf("cs_isa_probe: unable to map memory space\n"); 187 maddr = ISA_UNKNOWN_IOMEM; 188 } else 189 have_mem = 1; 190 191 ia->ia_nio = 1; 192 ia->ia_io[0].ir_size = CS8900_IOSIZE; 193 194 if (maddr == ISA_UNKNOWN_IOMEM) 195 ia->ia_niomem = 0; 196 else { 197 ia->ia_niomem = 1; 198 ia->ia_iomem[0].ir_addr = maddr; 199 ia->ia_iomem[0].ir_size = CS8900_MEMSIZE; 200 } 201 202 ia->ia_nirq = 1; 203 ia->ia_irq[0].ir_irq = irq; 204 205 rv = 1; 206 207 out: 208 if (have_io) 209 bus_space_unmap(iot, ioh, CS8900_IOSIZE); 210 if (have_mem) 211 bus_space_unmap(memt, memh, CS8900_MEMSIZE); 212 213 return (rv); 214 } 215 216 void 217 cs_isa_attach(struct device *parent, struct device *self, void *aux) 218 { 219 struct cs_softc *sc = (struct cs_softc *) self; 220 struct cs_softc_isa *isc = (void *) self; 221 struct isa_attach_args *ia = aux; 222 223 isc->sc_ic = ia->ia_ic; 224 sc->sc_iot = ia->ia_iot; 225 sc->sc_memt = ia->ia_memt; 226 227 if (ia->ia_ndrq > 0) 228 isc->sc_drq = ia->ia_drq[0].ir_drq; 229 else 230 isc->sc_drq = -1; 231 232 sc->sc_irq = ia->ia_irq[0].ir_irq; 233 234 printf("\n"); 235 236 /* 237 * Map the device. 238 */ 239 if (bus_space_map(sc->sc_iot, ia->ia_io[0].ir_addr, CS8900_IOSIZE, 240 0, &sc->sc_ioh)) { 241 printf("%s: unable to map i/o space\n", sc->sc_dev.dv_xname); 242 return; 243 } 244 245 /* 246 * Validate IRQ. 247 */ 248 if (CS8900_IRQ_ISVALID(sc->sc_irq) == 0) { 249 printf("%s: invalid IRQ %d\n", sc->sc_dev.dv_xname, sc->sc_irq); 250 return; 251 } 252 253 /* 254 * Map the memory space if it was specified. If we can do this, 255 * we set ourselves up to use memory mode forever. Otherwise, 256 * we fall back on I/O mode. 257 */ 258 if (ia->ia_iomem[0].ir_addr != ISA_UNKNOWN_IOMEM && 259 ia->ia_iomem[0].ir_size == CS8900_MEMSIZE && 260 CS8900_MEMBASE_ISVALID(ia->ia_iomem[0].ir_addr)) { 261 if (bus_space_map(sc->sc_memt, ia->ia_iomem[0].ir_addr, 262 CS8900_MEMSIZE, 0, &sc->sc_memh)) { 263 printf("%s: unable to map memory space\n", 264 sc->sc_dev.dv_xname); 265 } else { 266 sc->sc_cfgflags |= CFGFLG_MEM_MODE; 267 sc->sc_pktpgaddr = ia->ia_iomem[0].ir_addr; 268 } 269 } 270 271 sc->sc_ih = isa_intr_establish(ia->ia_ic, sc->sc_irq, IST_EDGE, 272 IPL_NET, cs_intr, sc); 273 if (sc->sc_ih == NULL) { 274 printf("%s: unable to establish interrupt\n", 275 sc->sc_dev.dv_xname); 276 return; 277 } 278 279 sc->sc_dma_chipinit = cs_isa_dma_chipinit; 280 sc->sc_dma_attach = cs_isa_dma_attach; 281 sc->sc_dma_process_rx = cs_process_rx_dma; 282 283 cs_attach(sc, NULL, NULL, 0, 0); 284 } 285
Indexes created Tue Sep 23 23:09:58 GMT 2025