isp_sbus.c revision 1.10.2.2
1 /* $NetBSD: isp_sbus.c,v 1.10.2.2 2000/01/08 22:44:56 he Exp $ */ 2 /* 3 * SBus specific probe and attach routines for Qlogic ISP SCSI adapters. 4 * 5 * Copyright (c) 1997 by Matthew Jacob 6 * NASA AMES Research Center 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice immediately at the beginning of the file, without modification, 14 * 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 * 3. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 25 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 */ 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/device.h> 38 #include <sys/kernel.h> 39 #include <sys/malloc.h> 40 #include <sys/queue.h> 41 42 #include <machine/autoconf.h> 43 #include <machine/cpu.h> 44 #include <machine/param.h> 45 #include <machine/vmparam.h> 46 47 #include <dev/ic/isp_netbsd.h> 48 #include <dev/microcode/isp/asm_sbus.h> 49 #include <dev/sbus/sbusvar.h> 50 51 static u_int16_t isp_sbus_rd_reg __P((struct ispsoftc *, int)); 52 static void isp_sbus_wr_reg __P((struct ispsoftc *, int, u_int16_t)); 53 static int isp_sbus_mbxdma __P((struct ispsoftc *)); 54 static int isp_sbus_dmasetup __P((struct ispsoftc *, struct scsipi_xfer *, 55 ispreq_t *, u_int16_t *, u_int16_t)); 56 static void isp_sbus_dmateardown __P((struct ispsoftc *, struct scsipi_xfer *, 57 u_int32_t)); 58 59 #ifndef ISP_1000_RISC_CODE 60 #define ISP_1000_RISC_CODE NULL 61 #endif 62 #ifndef ISP_CODE_ORG 63 #define ISP_CODE_ORG 0x1000 64 #endif 65 66 static struct ispmdvec mdvec = { 67 isp_sbus_rd_reg, 68 isp_sbus_wr_reg, 69 isp_sbus_mbxdma, 70 isp_sbus_dmasetup, 71 isp_sbus_dmateardown, 72 NULL, 73 NULL, 74 NULL, 75 ISP_1000_RISC_CODE, 0, ISP_CODE_ORG, 0, 76 BIU_BURST_ENABLE 77 }; 78 79 struct isp_sbussoftc { 80 struct ispsoftc sbus_isp; 81 sdparam sbus_dev; 82 bus_space_tag_t sbus_bustag; 83 bus_dma_tag_t sbus_dmatag; 84 bus_space_handle_t sbus_reg; 85 int sbus_node; 86 int sbus_pri; 87 struct ispmdvec sbus_mdvec; 88 bus_dmamap_t *sbus_dmamap; 89 int16_t sbus_poff[_NREG_BLKS]; 90 }; 91 92 93 static int isp_match __P((struct device *, struct cfdata *, void *)); 94 static void isp_sbus_attach __P((struct device *, struct device *, void *)); 95 struct cfattach isp_sbus_ca = { 96 sizeof (struct isp_sbussoftc), isp_match, isp_sbus_attach 97 }; 98 99 static int 100 isp_match(parent, cf, aux) 101 struct device *parent; 102 struct cfdata *cf; 103 void *aux; 104 { 105 int rv; 106 #ifdef DEBUG 107 static int oneshot = 1; 108 #endif 109 struct sbus_attach_args *sa = aux; 110 111 rv = (strcmp(cf->cf_driver->cd_name, sa->sa_name) == 0 || 112 strcmp("PTI,ptisp", sa->sa_name) == 0 || 113 strcmp("ptisp", sa->sa_name) == 0 || 114 strcmp("SUNW,isp", sa->sa_name) == 0 || 115 strcmp("QLGC,isp", sa->sa_name) == 0); 116 #ifdef DEBUG 117 if (rv && oneshot) { 118 oneshot = 0; 119 printf("Qlogic ISP Driver, NetBSD (sbus) Platform Version " 120 "%d.%d Core Version %d.%d\n", 121 ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR, 122 ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR); 123 } 124 #endif 125 return (rv); 126 } 127 128 static void 129 isp_sbus_attach(parent, self, aux) 130 struct device *parent, *self; 131 void *aux; 132 { 133 int i, freq; 134 struct sbus_attach_args *sa = aux; 135 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) self; 136 struct ispsoftc *isp = &sbc->sbus_isp; 137 ISP_LOCKVAL_DECL; 138 139 printf(" for %s\n", sa->sa_name); 140 141 sbc->sbus_bustag = sa->sa_bustag; 142 sbc->sbus_dmatag = sa->sa_dmatag; 143 if (sa->sa_nintr != 0) 144 sbc->sbus_pri = sa->sa_pri; 145 sbc->sbus_mdvec = mdvec; 146 147 if (sa->sa_npromvaddrs != 0) { 148 sbc->sbus_reg = (bus_space_handle_t)sa->sa_promvaddrs[0]; 149 } else { 150 if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, sa->sa_offset, 151 sa->sa_size, BUS_SPACE_MAP_LINEAR, 0, 152 &sbc->sbus_reg) != 0) { 153 printf("%s: cannot map registers\n", self->dv_xname); 154 return; 155 } 156 } 157 sbc->sbus_node = sa->sa_node; 158 159 freq = getpropint(sa->sa_node, "clock-frequency", 0); 160 if (freq) { 161 /* 162 * Convert from HZ to MHz, rounding up. 163 */ 164 freq = (freq + 500000)/1000000; 165 #if 0 166 printf("%s: %d MHz\n", self->dv_xname, freq); 167 #endif 168 } 169 sbc->sbus_mdvec.dv_clock = freq; 170 171 /* 172 * XXX: Now figure out what the proper burst sizes, etc., to use. 173 */ 174 sbc->sbus_mdvec.dv_conf1 |= BIU_SBUS_CONF1_FIFO_8; 175 176 /* 177 * Some early versions of the PTI SBus adapter 178 * would fail in trying to download (via poking) 179 * FW. We give up on them. 180 */ 181 if (strcmp("PTI,ptisp", sa->sa_name) == 0 || 182 strcmp("ptisp", sa->sa_name) == 0) { 183 sbc->sbus_mdvec.dv_fwlen = 0; 184 } 185 186 isp->isp_mdvec = &sbc->sbus_mdvec; 187 isp->isp_bustype = ISP_BT_SBUS; 188 isp->isp_type = ISP_HA_SCSI_UNKNOWN; 189 isp->isp_param = &sbc->sbus_dev; 190 bzero(isp->isp_param, sizeof (sdparam)); 191 192 sbc->sbus_poff[BIU_BLOCK >> _BLK_REG_SHFT] = BIU_REGS_OFF; 193 sbc->sbus_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = SBUS_MBOX_REGS_OFF; 194 sbc->sbus_poff[SXP_BLOCK >> _BLK_REG_SHFT] = SBUS_SXP_REGS_OFF; 195 sbc->sbus_poff[RISC_BLOCK >> _BLK_REG_SHFT] = SBUS_RISC_REGS_OFF; 196 sbc->sbus_poff[DMA_BLOCK >> _BLK_REG_SHFT] = DMA_REGS_OFF; 197 198 isp->isp_confopts = self->dv_cfdata->cf_flags; 199 ISP_LOCK(isp); 200 isp_reset(isp); 201 if (isp->isp_state != ISP_RESETSTATE) { 202 ISP_UNLOCK(isp); 203 return; 204 } 205 isp_init(isp); 206 if (isp->isp_state != ISP_INITSTATE) { 207 isp_uninit(isp); 208 ISP_UNLOCK(isp); 209 return; 210 } 211 212 for (i = 0; i < isp->isp_maxcmds; i++) { 213 /* Allocate a DMA handle */ 214 if (bus_dmamap_create(sbc->sbus_dmatag, MAXPHYS, 1, MAXPHYS, 0, 215 BUS_DMA_NOWAIT, &sbc->sbus_dmamap[i]) != 0) { 216 printf("%s: DMA map create error\n", 217 self->dv_xname); 218 return; 219 } 220 } 221 222 /* Establish interrupt channel */ 223 bus_intr_establish(sbc->sbus_bustag, sbc->sbus_pri, 0, 224 (int(*)__P((void*)))isp_intr, sbc); 225 226 /* 227 * do generic attach. 228 */ 229 isp_attach(isp); 230 if (isp->isp_state != ISP_RUNSTATE) { 231 isp_uninit(isp); 232 } 233 ISP_UNLOCK(isp); 234 } 235 236 static u_int16_t 237 isp_sbus_rd_reg(isp, regoff) 238 struct ispsoftc *isp; 239 int regoff; 240 { 241 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 242 int offset = sbc->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT]; 243 offset += (regoff & 0xff); 244 return (bus_space_read_2(sbc->sbus_bustag, sbc->sbus_reg, offset)); 245 } 246 247 static void 248 isp_sbus_wr_reg(isp, regoff, val) 249 struct ispsoftc *isp; 250 int regoff; 251 u_int16_t val; 252 { 253 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 254 int offset = sbc->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT]; 255 offset += (regoff & 0xff); 256 bus_space_write_2(sbc->sbus_bustag, sbc->sbus_reg, offset, val); 257 } 258 259 static int 260 isp_sbus_mbxdma(isp) 261 struct ispsoftc *isp; 262 { 263 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 264 bus_dma_segment_t seg; 265 int rseg; 266 size_t n; 267 bus_size_t len; 268 269 if (isp->isp_rquest_dma) 270 return (0); 271 272 n = sizeof (ISP_SCSI_XFER_T **) * isp->isp_maxcmds; 273 isp->isp_xflist = (ISP_SCSI_XFER_T **) malloc(n, M_DEVBUF, M_WAITOK); 274 if (isp->isp_xflist == NULL) { 275 printf("%s: cannot alloc xflist array\n", isp->isp_name); 276 return (1); 277 } 278 bzero(isp->isp_xflist, n); 279 n = sizeof (bus_dmamap_t) * isp->isp_maxcmds; 280 sbc->sbus_dmamap = (bus_dmamap_t *) malloc(n, M_DEVBUF, M_WAITOK); 281 if (sbc->sbus_dmamap == NULL) { 282 free(isp->isp_xflist, M_DEVBUF); 283 printf("%s: cannot alloc dmamap array\n", isp->isp_name); 284 return (1); 285 } 286 /* 287 * Allocate and map the request queue. 288 */ 289 len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN); 290 if (bus_dmamem_alloc(sbc->sbus_dmatag, len, NBPG, 0, 291 &seg, 1, &rseg, BUS_DMA_NOWAIT)) { 292 free(sbc->sbus_dmamap, M_DEVBUF); 293 free(isp->isp_xflist, M_DEVBUF); 294 return (1); 295 } 296 297 if (bus_dmamem_map(sbc->sbus_dmatag, &seg, rseg, len, 298 (caddr_t *)&isp->isp_rquest, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) { 299 free(sbc->sbus_dmamap, M_DEVBUF); 300 free(isp->isp_xflist, M_DEVBUF); 301 return (1); 302 } 303 isp->isp_rquest_dma = seg.ds_addr; 304 305 /* 306 * Allocate and map the result queue. 307 */ 308 len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN); 309 if (bus_dmamem_alloc(sbc->sbus_dmatag, len, NBPG, 0, 310 &seg, 1, &rseg, BUS_DMA_NOWAIT)) { 311 free(sbc->sbus_dmamap, M_DEVBUF); 312 free(isp->isp_xflist, M_DEVBUF); 313 return (1); 314 } 315 if (bus_dmamem_map(sbc->sbus_dmatag, &seg, rseg, len, 316 (caddr_t *)&isp->isp_result, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) { 317 free(sbc->sbus_dmamap, M_DEVBUF); 318 free(isp->isp_xflist, M_DEVBUF); 319 return (1); 320 } 321 isp->isp_result_dma = seg.ds_addr; 322 return (0); 323 } 324 325 /* 326 * Map a DMA request. 327 * We're guaranteed that rq->req_handle is a value from 1 to isp->isp_maxcmds. 328 */ 329 330 static int 331 isp_sbus_dmasetup(isp, xs, rq, iptrp, optr) 332 struct ispsoftc *isp; 333 struct scsipi_xfer *xs; 334 ispreq_t *rq; 335 u_int16_t *iptrp; 336 u_int16_t optr; 337 { 338 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 339 bus_dmamap_t dmamap; 340 int dosleep = (xs->flags & SCSI_NOSLEEP) != 0; 341 int in = (xs->flags & SCSI_DATA_IN) != 0; 342 343 if (xs->datalen == 0) { 344 rq->req_seg_count = 1; 345 goto mbxsync; 346 } 347 assert(rq->req_handle != 0 && rq->req_handle <= isp->isp_maxcmds); 348 dmamap = sbc->sbus_dmamap[rq->req_handle - 1]; 349 if (dmamap->dm_nsegs != 0) { 350 panic("%s: dma map already allocated\n", isp->isp_name); 351 /* NOTREACHED */ 352 } 353 if (bus_dmamap_load(sbc->sbus_dmatag, dmamap, xs->data, xs->datalen, 354 NULL, dosleep ? BUS_DMA_WAITOK : BUS_DMA_NOWAIT) != 0) { 355 XS_SETERR(xs, HBA_BOTCH); 356 return (CMD_COMPLETE); 357 } 358 bus_dmamap_sync(sbc->sbus_dmatag, dmamap, dmamap->dm_segs[0].ds_addr, 359 xs->datalen, in? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); 360 if (in) { 361 rq->req_flags |= REQFLAG_DATA_IN; 362 } else { 363 rq->req_flags |= REQFLAG_DATA_OUT; 364 } 365 rq->req_dataseg[0].ds_count = xs->datalen; 366 rq->req_dataseg[0].ds_base = dmamap->dm_segs[0].ds_addr; 367 rq->req_seg_count = 1; 368 mbxsync: 369 ISP_SWIZZLE_REQUEST(isp, rq); 370 #if 0 371 /* 372 * If we ever map cacheable memory, we need to do something like this. 373 */ 374 bus_dmamap_sync(sbc->sbus_dmat, sbc->sbus_rquest_dmap, 0, 375 sbc->sbus_rquest_dmap->dm_mapsize, BUS_DMASYNC_PREWRITE); 376 #endif 377 return (CMD_QUEUED); 378 } 379 380 static void 381 isp_sbus_dmateardown(isp, xs, handle) 382 struct ispsoftc *isp; 383 struct scsipi_xfer *xs; 384 u_int32_t handle; 385 { 386 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 387 bus_dmamap_t dmamap; 388 assert(handle != 0 && handle <= isp->isp_maxcmds); 389 dmamap = sbc->sbus_dmamap[handle-1]; 390 if (dmamap->dm_nsegs == 0) { 391 panic("%s: dma map not already allocated\n", isp->isp_name); 392 /* NOTREACHED */ 393 } 394 bus_dmamap_sync(sbc->sbus_dmatag, dmamap, dmamap->dm_segs[0].ds_addr, 395 xs->datalen, (xs->flags & SCSI_DATA_IN)? 396 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); 397 bus_dmamap_unload(sbc->sbus_dmatag, dmamap); 398 } 399
Indexes created Tue Oct 21 12:09:54 GMT 2025