ncr53c500_pccard.c revision 113315
1/* $FreeBSD: head/sys/dev/ncv/ncr53c500_pccard.c 113315 2003-04-10 04:36:02Z imp $ */ 2/* $NecBSD: ncr53c500_pisa.c,v 1.28 1998/11/26 01:59:11 honda Exp $ */ 3/* $NetBSD$ */ 4 5/* 6 * [Ported for FreeBSD] 7 * Copyright (c) 2000 8 * Noriaki Mitsunaga, Mitsuru Iwasaki and Takanori Watanabe. 9 * All rights reserved. 10 * [NetBSD for NEC PC-98 series] 11 * Copyright (c) 1995, 1996, 1997, 1998 12 * NetBSD/pc98 porting staff. All rights reserved. 13 * Copyright (c) 1995, 1996, 1997, 1998 14 * Naofumi HONDA. All rights reserved. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 1. Redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer. 21 * 2. Redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution. 24 * 3. The name of the author may not be used to endorse or promote products 25 * derived from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 28 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 29 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 30 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 31 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 32 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 33 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 34 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 35 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 36 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40#include <sys/param.h> 41#include <sys/systm.h> 42#include <sys/malloc.h> 43#include <sys/errno.h> 44 45#include <machine/bus.h> 46#include <machine/bus_pio.h> 47#include <machine/dvcfg.h> 48 49#include <sys/device_port.h> 50 51#include <dev/pccard/pccarddevs.h> 52#include <dev/pccard/pccardvar.h> 53 54#include <cam/scsi/scsi_low.h> 55#include <cam/scsi/scsi_low_pisa.h> 56 57#include <dev/ncv/ncr53c500reg.h> 58#include <dev/ncv/ncr53c500hw.h> 59#include <dev/ncv/ncr53c500var.h> 60 61#define KME_KXLC004_01 0x100 62#define OFFSET_KME_KXLC004_01 0x10 63 64#include <sys/kernel.h> 65#include <sys/module.h> 66#if !defined(__FreeBSD__) || __FreeBSD_version < 500014 67#include <sys/select.h> 68#endif 69#include <pccard/cardinfo.h> 70#include <pccard/slot.h> 71 72static int ncvprobe(DEVPORT_PDEVICE devi); 73static int ncvattach(DEVPORT_PDEVICE devi); 74 75static void ncv_card_unload(DEVPORT_PDEVICE); 76 77static const struct ncv_product { 78 struct pccard_product prod; 79 int flags; 80} ncv_products[] = { 81 { PCMCIA_CARD(EPSON, SC200, 0), 0}, 82 { PCMCIA_CARD(PANASONIC, KXLC002, 0), 0xb4d00000 }, 83 { PCMCIA_CARD(PANASONIC, KXLC004, 0), 0xb4d00100 }, 84 { PCMCIA_CARD(MACNICA, MPS100, 0), 0xb6250000 }, 85 { PCMCIA_CARD(MACNICA, MPS110, 0), 0 }, 86 { PCMCIA_CARD(NEC, PC9801N_J03R, 0), 0 }, 87 { PCMCIA_CARD(NEWMEDIA, BASICS_SCSI, 0), 0 }, 88 { PCMCIA_CARD(QLOGIC, PC05, 0), 0x84d00000 }, 89#define FLAGS_REX5572 0x84d00000 90 { PCMCIA_CARD(RATOC, REX5572, 0), FLAGS_REX5572 }, 91 { PCMCIA_CARD(RATOC, REX9530, 0), 0x84d00000 }, 92 { { NULL }, 0 } 93}; 94 95/* 96 * Additional code for FreeBSD new-bus PCCard frontend 97 */ 98 99static void 100ncv_pccard_intr(void * arg) 101{ 102 ncvintr(arg); 103} 104 105static void 106ncv_release_resource(DEVPORT_PDEVICE dev) 107{ 108 struct ncv_softc *sc = device_get_softc(dev); 109 110 if (sc->ncv_intrhand) { 111 bus_teardown_intr(dev, sc->irq_res, sc->ncv_intrhand); 112 } 113 114 if (sc->port_res) { 115 bus_release_resource(dev, SYS_RES_IOPORT, 116 sc->port_rid, sc->port_res); 117 } 118 119 if (sc->port_res_dmy) { 120 bus_release_resource(dev, SYS_RES_IOPORT, 121 sc->port_rid_dmy, sc->port_res_dmy); 122 } 123 124 if (sc->irq_res) { 125 bus_release_resource(dev, SYS_RES_IRQ, 126 sc->irq_rid, sc->irq_res); 127 } 128 129 if (sc->mem_res) { 130 bus_release_resource(dev, SYS_RES_MEMORY, 131 sc->mem_rid, sc->mem_res); 132 } 133} 134 135static int 136ncv_alloc_resource(DEVPORT_PDEVICE dev) 137{ 138 struct ncv_softc *sc = device_get_softc(dev); 139 u_int32_t flags = DEVPORT_PDEVFLAGS(dev); 140 u_long ioaddr, iosize, maddr, msize; 141 int error; 142 bus_addr_t offset = 0; 143 144 if(flags & KME_KXLC004_01) 145 offset = OFFSET_KME_KXLC004_01; 146 147 error = bus_get_resource(dev, SYS_RES_IOPORT, 0, &ioaddr, &iosize); 148 if (error || (iosize < (offset + NCVIOSZ))) { 149 return(ENOMEM); 150 } 151 152 sc->port_rid = 0; 153 sc->port_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->port_rid, 154 ioaddr+offset, ioaddr+iosize-offset, 155 iosize-offset, RF_ACTIVE); 156 if (sc->port_res == NULL) { 157 ncv_release_resource(dev); 158 return(ENOMEM); 159 } 160 161 if (offset != 0) { 162 sc->port_rid_dmy = 0; 163 sc->port_res_dmy = bus_alloc_resource(dev, SYS_RES_IOPORT, 164 &sc->port_rid_dmy, 165 ioaddr, ioaddr+offset, offset, 166 RF_ACTIVE); 167 if (sc->port_res_dmy == NULL) { 168 printf("Warning: cannot allocate IOPORT partially.\n"); 169 } 170 } else { 171 sc->port_rid_dmy = 0; 172 sc->port_res_dmy = NULL; 173 } 174 175 sc->irq_rid = 0; 176 sc->irq_res = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irq_rid, 177 0, ~0, 1, RF_ACTIVE); 178 if (sc->irq_res == NULL) { 179 ncv_release_resource(dev); 180 return(ENOMEM); 181 } 182 183 error = bus_get_resource(dev, SYS_RES_MEMORY, 0, &maddr, &msize); 184 if (error) { 185 return(0); /* XXX */ 186 } 187 188 /* no need to allocate memory if not configured */ 189 if (maddr == 0 || msize == 0) { 190 return(0); 191 } 192 193 sc->mem_rid = 0; 194 sc->mem_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &sc->mem_rid, 195 0, ~0, 1, RF_ACTIVE); 196 if (sc->mem_res == NULL) { 197 ncv_release_resource(dev); 198 return(ENOMEM); 199 } 200 201 return(0); 202} 203 204static int ncv_pccard_match(device_t dev) 205{ 206 const struct ncv_product *pp; 207 char *vendorstr; 208 char *prodstr; 209 210 if ((pp = (const struct ncv_product *) pccard_product_lookup(dev, 211 (const struct pccard_product *) ncv_products, 212 sizeof(ncv_products[0]), NULL)) != NULL) { 213 if (pp->prod.pp_name != NULL) 214 device_set_desc(dev, pp->prod.pp_name); 215 device_set_flags(dev, pp->flags); 216 return(0); 217 } 218 if (pccard_get_vendor_str(dev, &vendorstr)) 219 return(EIO); 220 if (pccard_get_product_str(dev, &prodstr)) 221 return(EIO); 222 if (strcmp(vendorstr, "RATOC System Inc.") == 0 && 223 strncmp(prodstr, "SOUND/SCSI2 CARD", 16) == 0) { 224 device_set_desc(dev, "RATOC REX-5572"); 225 device_set_flags(dev, FLAGS_REX5572); 226 return (0); 227 } 228 return(EIO); 229} 230 231static int 232ncv_pccard_probe(DEVPORT_PDEVICE dev) 233{ 234 struct ncv_softc *sc = device_get_softc(dev); 235 int error; 236 237 bzero(sc, sizeof(struct ncv_softc)); 238 239 error = ncv_alloc_resource(dev); 240 if (error) { 241 return(error); 242 } 243 244 if (ncvprobe(dev) == 0) { 245 ncv_release_resource(dev); 246 return(ENXIO); 247 } 248 249 ncv_release_resource(dev); 250 251 return(0); 252} 253 254static int 255ncv_pccard_attach(DEVPORT_PDEVICE dev) 256{ 257 struct ncv_softc *sc = device_get_softc(dev); 258 int error; 259 260 error = ncv_alloc_resource(dev); 261 if (error) { 262 return(error); 263 } 264 265 error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_CAM | INTR_ENTROPY, 266 ncv_pccard_intr, (void *)sc, &sc->ncv_intrhand); 267 if (error) { 268 ncv_release_resource(dev); 269 return(error); 270 } 271 272 if (ncvattach(dev) == 0) { 273 ncv_release_resource(dev); 274 return(ENXIO); 275 } 276 277 return(0); 278} 279 280static void 281ncv_pccard_detach(DEVPORT_PDEVICE dev) 282{ 283 ncv_card_unload(dev); 284 ncv_release_resource(dev); 285} 286 287static device_method_t ncv_pccard_methods[] = { 288 /* Device interface */ 289 DEVMETHOD(device_probe, pccard_compat_probe), 290 DEVMETHOD(device_attach, pccard_compat_attach), 291 DEVMETHOD(device_detach, ncv_pccard_detach), 292 293 /* Card interface */ 294 DEVMETHOD(card_compat_match, ncv_pccard_match), 295 DEVMETHOD(card_compat_probe, ncv_pccard_probe), 296 DEVMETHOD(card_compat_attach, ncv_pccard_attach), 297 298 { 0, 0 } 299}; 300 301static driver_t ncv_pccard_driver = { 302 "ncv", 303 ncv_pccard_methods, 304 sizeof(struct ncv_softc), 305}; 306 307static devclass_t ncv_devclass; 308 309MODULE_DEPEND(ncv, scsi_low, 1, 1, 1); 310DRIVER_MODULE(ncv, pccard, ncv_pccard_driver, ncv_devclass, 0, 0); 311 312static void 313ncv_card_unload(DEVPORT_PDEVICE devi) 314{ 315 struct ncv_softc *sc = DEVPORT_PDEVGET_SOFTC(devi); 316 intrmask_t s; 317 318 printf("%s: unload\n", sc->sc_sclow.sl_xname); 319 s = splcam(); 320 scsi_low_deactivate((struct scsi_low_softc *)sc); 321 scsi_low_dettach(&sc->sc_sclow); 322 splx(s); 323} 324 325static int 326ncvprobe(DEVPORT_PDEVICE devi) 327{ 328 int rv; 329 struct ncv_softc *sc = device_get_softc(devi); 330 u_int32_t flags = DEVPORT_PDEVFLAGS(devi); 331 332 rv = ncvprobesubr(rman_get_bustag(sc->port_res), 333 rman_get_bushandle(sc->port_res), 334 flags, NCV_HOSTID); 335 336 return rv; 337} 338 339static int 340ncvattach(DEVPORT_PDEVICE devi) 341{ 342 struct ncv_softc *sc; 343 struct scsi_low_softc *slp; 344 u_int32_t flags = DEVPORT_PDEVFLAGS(devi); 345 intrmask_t s; 346 char dvname[16]; /* SCSI_LOW_DVNAME_LEN */ 347 348 strcpy(dvname, "ncv"); 349 350 sc = DEVPORT_PDEVALLOC_SOFTC(devi); 351 if (sc == NULL) { 352 return(0); 353 } 354 355 slp = &sc->sc_sclow; 356 slp->sl_dev = devi; 357 sc->sc_iot = rman_get_bustag(sc->port_res); 358 sc->sc_ioh = rman_get_bushandle(sc->port_res); 359 360 slp->sl_hostid = NCV_HOSTID; 361 slp->sl_cfgflags = flags; 362 363 s = splcam(); 364 ncvattachsubr(sc); 365 splx(s); 366 367 return(NCVIOSZ); 368} 369