isp_sbus.c revision 1.14.4.1
1 /* $NetBSD: isp_sbus.c,v 1.14.4.1 1999/11/15 00:41:21 fvdl 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/sbus/sbusvar.h> 49 50 static u_int16_t isp_sbus_rd_reg __P((struct ispsoftc *, int)); 51 static void isp_sbus_wr_reg __P((struct ispsoftc *, int, u_int16_t)); 52 static int isp_sbus_mbxdma __P((struct ispsoftc *)); 53 static int isp_sbus_dmasetup __P((struct ispsoftc *, struct scsipi_xfer *, 54 ispreq_t *, u_int8_t *, u_int8_t)); 55 static void isp_sbus_dmateardown __P((struct ispsoftc *, struct scsipi_xfer *, 56 u_int32_t)); 57 58 static struct ispmdvec mdvec = { 59 isp_sbus_rd_reg, 60 isp_sbus_wr_reg, 61 isp_sbus_mbxdma, 62 isp_sbus_dmasetup, 63 isp_sbus_dmateardown, 64 NULL, 65 NULL, 66 NULL, 67 0, 68 0, 69 0, 70 0, 71 BIU_BURST_ENABLE, 72 0 73 }; 74 75 struct isp_sbussoftc { 76 struct ispsoftc sbus_isp; 77 sdparam sbus_dev; 78 bus_space_tag_t sbus_bustag; 79 bus_dma_tag_t sbus_dmatag; 80 bus_space_handle_t sbus_reg; 81 int sbus_node; 82 int sbus_pri; 83 struct ispmdvec sbus_mdvec; 84 bus_dmamap_t *sbus_dmamap; 85 int16_t sbus_poff[_NREG_BLKS]; 86 }; 87 88 89 static int isp_match __P((struct device *, struct cfdata *, void *)); 90 static void isp_sbus_attach __P((struct device *, struct device *, void *)); 91 struct cfattach isp_sbus_ca = { 92 sizeof (struct isp_sbussoftc), isp_match, isp_sbus_attach 93 }; 94 95 static int 96 isp_match(parent, cf, aux) 97 struct device *parent; 98 struct cfdata *cf; 99 void *aux; 100 { 101 int rv; 102 #ifdef DEBUG 103 static int oneshot = 1; 104 #endif 105 struct sbus_attach_args *sa = aux; 106 107 rv = (strcmp(cf->cf_driver->cd_name, sa->sa_name) == 0 || 108 strcmp("PTI,ptisp", sa->sa_name) == 0 || 109 strcmp("ptisp", sa->sa_name) == 0 || 110 strcmp("SUNW,isp", sa->sa_name) == 0 || 111 strcmp("QLGC,isp", sa->sa_name) == 0); 112 #ifdef DEBUG 113 if (rv && oneshot) { 114 oneshot = 0; 115 printf("Qlogic ISP Driver, NetBSD (sbus) Platform Version " 116 "%d.%d Core Version %d.%d\n", 117 ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR, 118 ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR); 119 } 120 #endif 121 return (rv); 122 } 123 124 static void 125 isp_sbus_attach(parent, self, aux) 126 struct device *parent, *self; 127 void *aux; 128 { 129 int i, freq; 130 struct sbus_attach_args *sa = aux; 131 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) self; 132 struct ispsoftc *isp = &sbc->sbus_isp; 133 ISP_LOCKVAL_DECL; 134 135 printf(" for %s\n", sa->sa_name); 136 137 sbc->sbus_bustag = sa->sa_bustag; 138 sbc->sbus_dmatag = sa->sa_dmatag; 139 sbc->sbus_pri = sa->sa_pri; 140 sbc->sbus_mdvec = mdvec; 141 142 if (sa->sa_npromvaddrs != 0) { 143 sbc->sbus_reg = (bus_space_handle_t)sa->sa_promvaddrs[0]; 144 } else { 145 if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, sa->sa_offset, 146 sa->sa_size, BUS_SPACE_MAP_LINEAR, 0, 147 &sbc->sbus_reg) != 0) { 148 printf("%s: cannot map registers\n", self->dv_xname); 149 return; 150 } 151 } 152 sbc->sbus_node = sa->sa_node; 153 154 freq = getpropint(sa->sa_node, "clock-frequency", 0); 155 if (freq) { 156 /* 157 * Convert from HZ to MHz, rounding up. 158 */ 159 freq = (freq + 500000)/1000000; 160 #if 0 161 printf("%s: %d MHz\n", self->dv_xname, freq); 162 #endif 163 } 164 sbc->sbus_mdvec.dv_clock = freq; 165 166 /* 167 * XXX: Now figure out what the proper burst sizes, etc., to use. 168 */ 169 sbc->sbus_mdvec.dv_conf1 |= BIU_SBUS_CONF1_FIFO_8; 170 171 /* 172 * Some early versions of the PTI SBus adapter 173 * would fail in trying to download (via poking) 174 * FW. We give up on them. 175 */ 176 if (strcmp("PTI,ptisp", sa->sa_name) == 0 || 177 strcmp("ptisp", sa->sa_name) == 0) { 178 sbc->sbus_mdvec.dv_fwlen = 0; 179 } 180 181 isp->isp_mdvec = &sbc->sbus_mdvec; 182 isp->isp_bustype = ISP_BT_SBUS; 183 isp->isp_type = ISP_HA_SCSI_UNKNOWN; 184 isp->isp_param = &sbc->sbus_dev; 185 bzero(isp->isp_param, sizeof (sdparam)); 186 187 sbc->sbus_poff[BIU_BLOCK >> _BLK_REG_SHFT] = BIU_REGS_OFF; 188 sbc->sbus_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = SBUS_MBOX_REGS_OFF; 189 sbc->sbus_poff[SXP_BLOCK >> _BLK_REG_SHFT] = SBUS_SXP_REGS_OFF; 190 sbc->sbus_poff[RISC_BLOCK >> _BLK_REG_SHFT] = SBUS_RISC_REGS_OFF; 191 sbc->sbus_poff[DMA_BLOCK >> _BLK_REG_SHFT] = DMA_REGS_OFF; 192 193 ISP_LOCK(isp); 194 isp_reset(isp); 195 if (isp->isp_state != ISP_RESETSTATE) { 196 ISP_UNLOCK(isp); 197 return; 198 } 199 isp_init(isp); 200 if (isp->isp_state != ISP_INITSTATE) { 201 isp_uninit(isp); 202 ISP_UNLOCK(isp); 203 return; 204 } 205 206 for (i = 0; i < isp->isp_maxcmds; i++) { 207 /* Allocate a DMA handle */ 208 if (bus_dmamap_create(sbc->sbus_dmatag, MAXPHYS, 1, MAXPHYS, 0, 209 BUS_DMA_NOWAIT, &sbc->sbus_dmamap[i]) != 0) { 210 printf("%s: DMA map create error\n", 211 self->dv_xname); 212 return; 213 } 214 } 215 216 /* Establish interrupt channel */ 217 bus_intr_establish(sbc->sbus_bustag, sbc->sbus_pri, 0, 218 (int(*)__P((void*)))isp_intr, sbc); 219 220 /* 221 * do generic attach. 222 */ 223 isp_attach(isp); 224 if (isp->isp_state != ISP_RUNSTATE) { 225 isp_uninit(isp); 226 } 227 ISP_UNLOCK(isp); 228 } 229 230 static u_int16_t 231 isp_sbus_rd_reg(isp, regoff) 232 struct ispsoftc *isp; 233 int regoff; 234 { 235 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 236 int offset = sbc->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT]; 237 offset += (regoff & 0xff); 238 return (bus_space_read_2(sbc->sbus_bustag, sbc->sbus_reg, offset)); 239 } 240 241 static void 242 isp_sbus_wr_reg(isp, regoff, val) 243 struct ispsoftc *isp; 244 int regoff; 245 u_int16_t val; 246 { 247 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 248 int offset = sbc->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT]; 249 offset += (regoff & 0xff); 250 bus_space_write_2(sbc->sbus_bustag, sbc->sbus_reg, offset, val); 251 } 252 253 static int 254 isp_sbus_mbxdma(isp) 255 struct ispsoftc *isp; 256 { 257 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 258 bus_dma_segment_t seg; 259 int rseg; 260 size_t n; 261 bus_size_t len; 262 263 if (isp->isp_rquest_dma) 264 return (0); 265 266 n = sizeof (ISP_SCSI_XFER_T **) * isp->isp_maxcmds; 267 isp->isp_xflist = (ISP_SCSI_XFER_T **) malloc(n, M_DEVBUF, M_WAITOK); 268 if (isp->isp_xflist == NULL) { 269 printf("%s: cannot alloc xflist array\n", isp->isp_name); 270 return (1); 271 } 272 bzero(isp->isp_xflist, n); 273 n = sizeof (bus_dmamap_t) * isp->isp_maxcmds; 274 sbc->sbus_dmamap = (bus_dmamap_t *) malloc(n, M_DEVBUF, M_WAITOK); 275 if (sbc->sbus_dmamap == NULL) { 276 free(isp->isp_xflist, M_DEVBUF); 277 printf("%s: cannot alloc dmamap array\n", isp->isp_name); 278 return (1); 279 } 280 /* 281 * Allocate and map the request queue. 282 */ 283 len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN); 284 if (bus_dmamem_alloc(sbc->sbus_dmatag, len, NBPG, 0, 285 &seg, 1, &rseg, BUS_DMA_NOWAIT)) { 286 free(sbc->sbus_dmamap, M_DEVBUF); 287 free(isp->isp_xflist, M_DEVBUF); 288 return (1); 289 } 290 291 if (bus_dmamem_map(sbc->sbus_dmatag, &seg, rseg, len, 292 (caddr_t *)&isp->isp_rquest, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) { 293 free(sbc->sbus_dmamap, M_DEVBUF); 294 free(isp->isp_xflist, M_DEVBUF); 295 return (1); 296 } 297 isp->isp_rquest_dma = seg.ds_addr; 298 299 /* 300 * Allocate and map the result queue. 301 */ 302 len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN); 303 if (bus_dmamem_alloc(sbc->sbus_dmatag, len, NBPG, 0, 304 &seg, 1, &rseg, BUS_DMA_NOWAIT)) { 305 free(sbc->sbus_dmamap, M_DEVBUF); 306 free(isp->isp_xflist, M_DEVBUF); 307 return (1); 308 } 309 if (bus_dmamem_map(sbc->sbus_dmatag, &seg, rseg, len, 310 (caddr_t *)&isp->isp_result, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) { 311 free(sbc->sbus_dmamap, M_DEVBUF); 312 free(isp->isp_xflist, M_DEVBUF); 313 return (1); 314 } 315 isp->isp_result_dma = seg.ds_addr; 316 return (0); 317 } 318 319 /* 320 * Map a DMA request. 321 * We're guaranteed that rq->req_handle is a value from 1 to isp->isp_maxcmds. 322 */ 323 324 static int 325 isp_sbus_dmasetup(isp, xs, rq, iptrp, optr) 326 struct ispsoftc *isp; 327 struct scsipi_xfer *xs; 328 ispreq_t *rq; 329 u_int8_t *iptrp; 330 u_int8_t optr; 331 { 332 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 333 bus_dmamap_t dmamap; 334 int dosleep = (xs->xs_control & XS_CTL_NOSLEEP) != 0; 335 int in = (xs->xs_control & XS_CTL_DATA_IN) != 0; 336 337 if (xs->datalen == 0) { 338 rq->req_seg_count = 1; 339 goto mbxsync; 340 } 341 assert(rq->req_handle != 0 && rq->req_handle <= isp->isp_maxcmds); 342 dmamap = sbc->sbus_dmamap[rq->req_handle - 1]; 343 if (dmamap->dm_nsegs != 0) { 344 panic("%s: dma map already allocated\n", isp->isp_name); 345 /* NOTREACHED */ 346 } 347 if (bus_dmamap_load(sbc->sbus_dmatag, dmamap, xs->data, xs->datalen, 348 NULL, dosleep ? BUS_DMA_WAITOK : BUS_DMA_NOWAIT) != 0) { 349 XS_SETERR(xs, HBA_BOTCH); 350 return (CMD_COMPLETE); 351 } 352 bus_dmamap_sync(sbc->sbus_dmatag, dmamap, dmamap->dm_segs[0].ds_addr, 353 xs->datalen, in? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE); 354 if (in) { 355 rq->req_flags |= REQFLAG_DATA_IN; 356 } else { 357 rq->req_flags |= REQFLAG_DATA_OUT; 358 } 359 rq->req_dataseg[0].ds_count = xs->datalen; 360 rq->req_dataseg[0].ds_base = dmamap->dm_segs[0].ds_addr; 361 rq->req_seg_count = 1; 362 mbxsync: 363 ISP_SWIZZLE_REQUEST(isp, rq); 364 #if 0 365 /* 366 * If we ever map cacheable memory, we need to do something like this. 367 */ 368 bus_dmamap_sync(sbc->sbus_dmat, sbc->sbus_rquest_dmap, 0, 369 sbc->sbus_rquest_dmap->dm_mapsize, BUS_DMASYNC_PREWRITE); 370 #endif 371 return (CMD_QUEUED); 372 } 373 374 static void 375 isp_sbus_dmateardown(isp, xs, handle) 376 struct ispsoftc *isp; 377 struct scsipi_xfer *xs; 378 u_int32_t handle; 379 { 380 struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp; 381 bus_dmamap_t dmamap; 382 assert(handle != 0 && handle <= isp->isp_maxcmds); 383 dmamap = sbc->sbus_dmamap[handle-1]; 384 if (dmamap->dm_nsegs == 0) { 385 panic("%s: dma map not already allocated\n", isp->isp_name); 386 /* NOTREACHED */ 387 } 388 bus_dmamap_sync(sbc->sbus_dmatag, dmamap, dmamap->dm_segs[0].ds_addr, 389 xs->datalen, (xs->xs_control & XS_CTL_DATA_IN)? 390 BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE); 391 bus_dmamap_unload(sbc->sbus_dmatag, dmamap); 392 } 393
Indexes created Sat Oct 25 16:10:12 GMT 2025