Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/nsp/nsp.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* $NecBSD: nsp.c,v 1.21.12.6 2001/06/29 06:27:52 honda Exp $ */ 2 /* $NetBSD$ */ 3 4 #define NSP_DEBUG 5 #define NSP_STATICS 6 #define NSP_IO_CONTROL_FLAGS \ 7 (NSP_READ_SUSPEND_IO | NSP_WRITE_SUSPEND_IO | \ 8 NSP_READ_FIFO_INTERRUPTS | NSP_WRITE_FIFO_INTERRUPTS | \ 9 NSP_USE_MEMIO | NSP_WAIT_FOR_SELECT) 10 11 /*- 12 * Copyright (c) 1998, 1999, 2000, 2001 13 * NetBSD/pc98 porting staff. All rights reserved. 14 * 15 * Copyright (c) 1998, 1999, 2000, 2001 16 * Naofumi HONDA. All rights reserved. 17 * 18 * Redistribution and use in source and binary forms, with or without 19 * modification, are permitted provided that the following conditions 20 * are met: 21 * 1. Redistributions of source code must retain the above copyright 22 * notice, this list of conditions and the following disclaimer. 23 * 2. Redistributions in binary form must reproduce the above copyright 24 * notice, this list of conditions and the following disclaimer in the 25 * documentation and/or other materials provided with the distribution. 26 * 3. The name of the author may not be used to endorse or promote products 27 * derived from this software without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 30 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 31 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 32 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, 33 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 34 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 35 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 37 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 38 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 39 * POSSIBILITY OF SUCH DAMAGE. 40 */ 41 42 #include <sys/cdefs.h> 43 __FBSDID("$FreeBSD: releng/6.0/sys/dev/nsp/nsp.c 146734 2005-05-29 04:42:30Z nyan $"); 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/kernel.h> 48 #if defined(__FreeBSD__) && __FreeBSD_version > 500001 49 #include <sys/bio.h> 50 #endif /* __ FreeBSD__ */ 51 #include <sys/buf.h> 52 #include <sys/queue.h> 53 #include <sys/malloc.h> 54 #include <sys/errno.h> 55 56 #ifdef __NetBSD__ 57 #include <sys/device.h> 58 #include <machine/bus.h> 59 #include <machine/intr.h> 60 61 #include <dev/scsipi/scsi_all.h> 62 #include <dev/scsipi/scsipi_all.h> 63 #include <dev/scsipi/scsiconf.h> 64 #include <dev/scsipi/scsi_disk.h> 65 66 #include <machine/dvcfg.h> 67 #include <machine/physio_proc.h> 68 69 #include <i386/Cbus/dev/scsi_low.h> 70 #include <i386/Cbus/dev/nspreg.h> 71 #include <i386/Cbus/dev/nspvar.h> 72 #endif /* __NetBSD__ */ 73 74 #ifdef __FreeBSD__ 75 #include <machine/clock.h> 76 #include <machine/cpu.h> 77 #include <machine/bus.h> 78 79 #include <compat/netbsd/dvcfg.h> 80 #include <compat/netbsd/physio_proc.h> 81 82 #include <cam/scsi/scsi_low.h> 83 #include <dev/nsp/nspreg.h> 84 #include <dev/nsp/nspvar.h> 85 #endif /* __FreeBSD__ */ 86 87 /*************************************************** 88 * USER SETTINGS 89 ***************************************************/ 90 /* DEVICE CONFIGURATION FLAGS (MINOR) 91 * 92 * 0x01 DISCONECT OFF 93 * 0x02 PARITY LINE OFF 94 * 0x04 IDENTIFY MSG OFF ( = single lun) 95 * 0x08 SYNC TRANSFER OFF 96 */ 97 98 /*************************************************** 99 * PARAMS 100 ***************************************************/ 101 #define NSP_NTARGETS 8 102 #define NSP_NLUNS 8 103 104 #define NSP_MAX_DATA_SIZE (64 * 1024) 105 #define NSP_SELTIMEOUT (200) 106 #define NSP_DELAY_MAX (2 * 1000 * 1000) 107 #define NSP_DELAY_INTERVAL (1) 108 #define NSP_TIMER_1MS (1000 / 51) 109 110 /*************************************************** 111 * DEBUG 112 ***************************************************/ 113 #ifdef NSP_DEBUG 114 int nsp_debug; 115 #endif /* NSP_DEBUG */ 116 117 #ifdef NSP_STATICS 118 struct nsp_statics { 119 int arbit_conflict_1; 120 int arbit_conflict_2; 121 int device_data_write; 122 int device_busy; 123 int disconnect; 124 int reselect; 125 int data_phase_bypass; 126 } nsp_statics; 127 #endif /* NSP_STATICS */ 128 129 /*************************************************** 130 * IO control 131 ***************************************************/ 132 #define NSP_READ_SUSPEND_IO 0x0001 133 #define NSP_WRITE_SUSPEND_IO 0x0002 134 #define NSP_USE_MEMIO 0x0004 135 #define NSP_READ_FIFO_INTERRUPTS 0x0010 136 #define NSP_WRITE_FIFO_INTERRUPTS 0x0020 137 #define NSP_WAIT_FOR_SELECT 0x0100 138 139 u_int nsp_io_control = NSP_IO_CONTROL_FLAGS; 140 int nsp_read_suspend_bytes = DEV_BSIZE; 141 int nsp_write_suspend_bytes = DEV_BSIZE; 142 int nsp_read_interrupt_bytes = 4096; 143 int nsp_write_interrupt_bytes = 4096; 144 145 /*************************************************** 146 * DEVICE STRUCTURE 147 ***************************************************/ 148 extern struct cfdriver nsp_cd; 149 150 /************************************************************** 151 * DECLARE 152 **************************************************************/ 153 #define NSP_FIFO_ON 1 154 #define NSP_FIFO_OFF 0 155 static void nsp_pio_read(struct nsp_softc *, int); 156 static void nsp_pio_write(struct nsp_softc *, int); 157 static int nsp_xfer(struct nsp_softc *, u_int8_t *, int, int, int); 158 static int nsp_msg(struct nsp_softc *, struct targ_info *, u_int); 159 static int nsp_reselected(struct nsp_softc *); 160 static int nsp_disconnected(struct nsp_softc *, struct targ_info *); 161 static void nsp_pdma_end(struct nsp_softc *, struct targ_info *); 162 static void nsphw_init(struct nsp_softc *); 163 static int nsp_target_nexus_establish(struct nsp_softc *); 164 static int nsp_lun_nexus_establish(struct nsp_softc *); 165 static int nsp_ccb_nexus_establish(struct nsp_softc *); 166 static int nsp_world_start(struct nsp_softc *, int); 167 static int nsphw_start_selection(struct nsp_softc *sc, struct slccb *); 168 static void nsphw_bus_reset(struct nsp_softc *); 169 static void nsphw_attention(struct nsp_softc *); 170 static u_int nsp_fifo_count(struct nsp_softc *); 171 static u_int nsp_request_count(struct nsp_softc *); 172 static int nsp_negate_signal(struct nsp_softc *, u_int8_t, u_char *); 173 static int nsp_expect_signal(struct nsp_softc *, u_int8_t, u_int8_t); 174 static void nsp_start_timer(struct nsp_softc *, int); 175 static void nsp_setup_fifo(struct nsp_softc *, int, int, int); 176 static int nsp_targ_init(struct nsp_softc *, struct targ_info *, int); 177 static void nsphw_selection_done_and_expect_msgout(struct nsp_softc *); 178 static void nsp_data_padding(struct nsp_softc *, int, u_int); 179 static int nsp_timeout(struct nsp_softc *); 180 static int nsp_read_fifo(struct nsp_softc *, int); 181 static int nsp_write_fifo(struct nsp_softc *, int); 182 static int nsp_phase_match(struct nsp_softc *, u_int8_t, u_int8_t); 183 static int nsp_wait_interrupt(struct nsp_softc *); 184 185 struct scsi_low_funcs nspfuncs = { 186 SC_LOW_INIT_T nsp_world_start, 187 SC_LOW_BUSRST_T nsphw_bus_reset, 188 SC_LOW_TARG_INIT_T nsp_targ_init, 189 SC_LOW_LUN_INIT_T NULL, 190 191 SC_LOW_SELECT_T nsphw_start_selection, 192 SC_LOW_NEXUS_T nsp_lun_nexus_establish, 193 SC_LOW_NEXUS_T nsp_ccb_nexus_establish, 194 195 SC_LOW_ATTEN_T nsphw_attention, 196 SC_LOW_MSG_T nsp_msg, 197 198 SC_LOW_TIMEOUT_T nsp_timeout, 199 SC_LOW_POLL_T nspintr, 200 201 NULL, 202 }; 203 204 /**************************************************** 205 * hwfuncs 206 ****************************************************/ 207 static __inline u_int8_t nsp_cr_read_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs); 208 static __inline void nsp_cr_write_1(bus_space_tag_t bst, bus_space_handle_t bsh, bus_addr_t ofs, u_int8_t va); 209 210 static __inline u_int8_t 211 nsp_cr_read_1(bst, bsh, ofs) 212 bus_space_tag_t bst; 213 bus_space_handle_t bsh; 214 bus_addr_t ofs; 215 { 216 217 bus_space_write_1(bst, bsh, nsp_idxr, ofs); 218 return bus_space_read_1(bst, bsh, nsp_datar); 219 } 220 221 static __inline void 222 nsp_cr_write_1(bst, bsh, ofs, va) 223 bus_space_tag_t bst; 224 bus_space_handle_t bsh; 225 bus_addr_t ofs; 226 u_int8_t va; 227 { 228 229 bus_space_write_1(bst, bsh, nsp_idxr, ofs); 230 bus_space_write_1(bst, bsh, nsp_datar, va); 231 } 232 233 static int 234 nsp_expect_signal(sc, curphase, mask) 235 struct nsp_softc *sc; 236 u_int8_t curphase, mask; 237 { 238 struct scsi_low_softc *slp = &sc->sc_sclow; 239 bus_space_tag_t bst = sc->sc_iot; 240 bus_space_handle_t bsh = sc->sc_ioh; 241 int wc; 242 u_int8_t ph, isrc; 243 244 for (wc = 0; wc < NSP_DELAY_MAX / NSP_DELAY_INTERVAL; wc ++) 245 { 246 ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON); 247 if (ph == (u_int8_t) -1) 248 return -1; 249 250 isrc = bus_space_read_1(bst, bsh, nsp_irqsr); 251 if (isrc & IRQSR_SCSI) 252 return 0; 253 254 if ((ph & mask) != 0 && (ph & SCBUSMON_PHMASK) == curphase) 255 return 1; 256 257 SCSI_LOW_DELAY(NSP_DELAY_INTERVAL); 258 } 259 260 printf("%s: nsp_expect_signal timeout\n", slp->sl_xname); 261 return -1; 262 } 263 264 static void 265 nsphw_init(sc) 266 struct nsp_softc *sc; 267 { 268 bus_space_tag_t bst = sc->sc_iot; 269 bus_space_handle_t bsh = sc->sc_ioh; 270 271 /* block all interrupts */ 272 bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_ALLMASK); 273 274 /* setup SCSI interface */ 275 bus_space_write_1(bst, bsh, nsp_ifselr, IFSELR_IFSEL); 276 277 nsp_cr_write_1(bst, bsh, NSPR_SCIENR, 0); 278 279 nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_IO8); 280 nsp_cr_write_1(bst, bsh, NSPR_CLKDIVR, sc->sc_iclkdiv); 281 282 nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr); 283 nsp_cr_write_1(bst, bsh, NSPR_PARITYR, sc->sc_parr); 284 nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, 285 PTCLRR_ACK | PTCLRR_REQ | PTCLRR_HOST | PTCLRR_RSS); 286 287 /* setup fifo asic */ 288 bus_space_write_1(bst, bsh, nsp_ifselr, IFSELR_REGSEL); 289 nsp_cr_write_1(bst, bsh, NSPR_TERMPWRC, 0); 290 if ((nsp_cr_read_1(bst, bsh, NSPR_OCR) & OCR_TERMPWRS) == 0) 291 nsp_cr_write_1(bst, bsh, NSPR_TERMPWRC, TERMPWRC_POWON); 292 293 nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_IO8); 294 nsp_cr_write_1(bst, bsh, NSPR_CLKDIVR, sc->sc_clkdiv); 295 nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0); 296 nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0); 297 298 nsp_cr_write_1(bst, bsh, NSPR_SYNCR, 0); 299 nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, 0); 300 301 /* enable interrupts and ack them */ 302 nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr); 303 bus_space_write_1(bst, bsh, nsp_irqcr, IRQSR_MASK); 304 305 nsp_setup_fifo(sc, NSP_FIFO_OFF, SCSI_LOW_READ, 0); 306 } 307 308 /**************************************************** 309 * scsi low interface 310 ****************************************************/ 311 static void 312 nsphw_attention(sc) 313 struct nsp_softc *sc; 314 { 315 bus_space_tag_t bst = sc->sc_iot; 316 bus_space_handle_t bsh = sc->sc_ioh; 317 u_int8_t cr; 318 319 cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR)/* & ~SCBUSCR_ACK */; 320 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr | SCBUSCR_ATN); 321 SCSI_LOW_DELAY(10); 322 } 323 324 static void 325 nsphw_bus_reset(sc) 326 struct nsp_softc *sc; 327 { 328 bus_space_tag_t bst = sc->sc_iot; 329 bus_space_handle_t bsh = sc->sc_ioh; 330 int i; 331 332 bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_ALLMASK); 333 334 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, SCBUSCR_RST); 335 SCSI_LOW_DELAY(100 * 1000); /* 100ms */ 336 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 0); 337 for (i = 0; i < 5; i ++) 338 (void) nsp_cr_read_1(bst, bsh, NSPR_IRQPHS); 339 340 bus_space_write_1(bst, bsh, nsp_irqcr, IRQSR_MASK); 341 } 342 343 static void 344 nsphw_selection_done_and_expect_msgout(sc) 345 struct nsp_softc *sc; 346 { 347 struct scsi_low_softc *slp = &sc->sc_sclow; 348 bus_space_tag_t bst = sc->sc_iot; 349 bus_space_handle_t bsh = sc->sc_ioh; 350 351 /* clear ack counter */ 352 sc->sc_cnt = 0; 353 nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_PT | PTCLRR_ACK | 354 PTCLRR_REQ | PTCLRR_HOST); 355 356 /* deassert sel and assert atten */ 357 sc->sc_seltout = 0; 358 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, sc->sc_busc); 359 SCSI_LOW_DELAY(1); 360 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 361 sc->sc_busc | SCBUSCR_ADIR | SCBUSCR_ACKEN); 362 SCSI_LOW_ASSERT_ATN(slp); 363 } 364 365 static int 366 nsphw_start_selection(sc, cb) 367 struct nsp_softc *sc; 368 struct slccb *cb; 369 { 370 struct scsi_low_softc *slp = &sc->sc_sclow; 371 bus_space_tag_t bst = sc->sc_iot; 372 bus_space_handle_t bsh = sc->sc_ioh; 373 struct targ_info *ti = cb->ti; 374 register u_int8_t arbs, ph; 375 int s, wc; 376 377 wc = sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000; 378 sc->sc_dataout_timeout = 0; 379 380 /* check bus free */ 381 s = splhigh(); 382 ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON); 383 if (ph != SCBUSMON_FREE) 384 { 385 splx(s); 386 #ifdef NSP_STATICS 387 nsp_statics.arbit_conflict_1 ++; 388 #endif /* NSP_STATICS */ 389 return SCSI_LOW_START_FAIL; 390 } 391 392 /* start arbitration */ 393 nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_EXEC); 394 splx(s); 395 396 SCSI_LOW_SETUP_PHASE(ti, PH_ARBSTART); 397 do 398 { 399 /* XXX: what a stupid chip! */ 400 arbs = nsp_cr_read_1(bst, bsh, NSPR_ARBITS); 401 SCSI_LOW_DELAY(1); 402 } 403 while ((arbs & (ARBITS_WIN | ARBITS_FAIL)) == 0 && wc -- > 0); 404 405 if ((arbs & ARBITS_WIN) == 0) 406 { 407 nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_CLR); 408 #ifdef NSP_STATICS 409 nsp_statics.arbit_conflict_2 ++; 410 #endif /* NSP_STATICS */ 411 return SCSI_LOW_START_FAIL; 412 } 413 414 /* assert select line */ 415 SCSI_LOW_SETUP_PHASE(ti, PH_SELSTART); 416 scsi_low_arbit_win(slp); 417 418 s = splhigh(); 419 SCSI_LOW_DELAY(3); 420 nsp_cr_write_1(bst, bsh, NSPR_DATA, 421 sc->sc_idbit | (1 << ti->ti_id)); 422 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 423 SCBUSCR_SEL | SCBUSCR_BSY | sc->sc_busc); 424 SCSI_LOW_DELAY(3); 425 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, SCBUSCR_SEL | 426 SCBUSCR_BSY | SCBUSCR_DOUT | sc->sc_busc); 427 nsp_cr_write_1(bst, bsh, NSPR_ARBITS, ARBITS_CLR); 428 SCSI_LOW_DELAY(3); 429 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 430 SCBUSCR_SEL | SCBUSCR_DOUT | sc->sc_busc); 431 SCSI_LOW_DELAY(1); 432 433 if ((nsp_io_control & NSP_WAIT_FOR_SELECT) != 0) 434 { 435 #define NSP_FIRST_SEL_WAIT 300 436 #define NSP_SEL_CHECK_INTERVAL 10 437 438 /* wait for a selection response */ 439 for (wc = 0; wc < NSP_FIRST_SEL_WAIT / NSP_SEL_CHECK_INTERVAL; 440 wc ++) 441 { 442 ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON); 443 if ((ph & SCBUSMON_BSY) == 0) 444 { 445 SCSI_LOW_DELAY(NSP_SEL_CHECK_INTERVAL); 446 continue; 447 } 448 449 SCSI_LOW_DELAY(1); 450 ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON); 451 if ((ph & SCBUSMON_BSY) != 0) 452 { 453 nsphw_selection_done_and_expect_msgout(sc); 454 splx(s); 455 456 SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED); 457 return SCSI_LOW_START_OK; 458 } 459 } 460 } 461 splx(s); 462 463 /* check a selection timeout */ 464 nsp_start_timer(sc, NSP_TIMER_1MS); 465 sc->sc_seltout = 1; 466 return SCSI_LOW_START_OK; 467 } 468 469 static int 470 nsp_world_start(sc, fdone) 471 struct nsp_softc *sc; 472 int fdone; 473 { 474 struct scsi_low_softc *slp = &sc->sc_sclow; 475 476 sc->sc_cnt = 0; 477 sc->sc_seltout = 0; 478 479 if ((slp->sl_cfgflags & CFG_NOATTEN) == 0) 480 sc->sc_busc = SCBUSCR_ATN; 481 else 482 sc->sc_busc = 0; 483 484 if ((slp->sl_cfgflags & CFG_NOPARITY) == 0) 485 sc->sc_parr = PARITYR_ENABLE | PARITYR_CLEAR; 486 else 487 sc->sc_parr = 0; 488 489 sc->sc_icr = (SCIENR_SCCHG | SCIENR_RESEL | SCIENR_RST); 490 491 nsphw_init(sc); 492 scsi_low_bus_reset(slp); 493 494 SOFT_INTR_REQUIRED(slp); 495 return 0; 496 } 497 498 struct ncp_synch_data { 499 u_int min_period; 500 u_int max_period; 501 u_int chip_period; 502 u_int ack_width; 503 }; 504 505 static struct ncp_synch_data ncp_sync_data_40M[] = { 506 {0x0c,0x0c,0x1,0}, /* 20MB 50ns*/ 507 {0x19,0x19,0x3,1}, /* 10MB 100ns*/ 508 {0x1a,0x25,0x5,2}, /* 7.5MB 150ns*/ 509 {0x26,0x32,0x7,3}, /* 5MB 200ns*/ 510 {0x0, 0, 0, 0} 511 }; 512 513 static struct ncp_synch_data ncp_sync_data_20M[] = { 514 {0x19,0x19,0x1,0}, /* 10MB 100ns*/ 515 {0x1a,0x25,0x2,0}, /* 7.5MB 150ns*/ 516 {0x26,0x32,0x3,1}, /* 5MB 200ns*/ 517 {0x0, 0, 0, 0} 518 }; 519 520 static int 521 nsp_msg(sc, ti, msg) 522 struct nsp_softc *sc; 523 struct targ_info *ti; 524 u_int msg; 525 { 526 bus_space_tag_t bst = sc->sc_iot; 527 bus_space_handle_t bsh = sc->sc_ioh; 528 struct ncp_synch_data *sdp; 529 struct nsp_targ_info *nti = (void *) ti; 530 u_int period, offset; 531 int i, error; 532 533 if ((msg & SCSI_LOW_MSG_WIDE) != 0) 534 { 535 if (ti->ti_width != SCSI_LOW_BUS_WIDTH_8) 536 { 537 ti->ti_width = SCSI_LOW_BUS_WIDTH_8; 538 return EINVAL; 539 } 540 return 0; 541 } 542 543 if ((msg & SCSI_LOW_MSG_SYNCH) == 0) 544 return 0; 545 546 period = ti->ti_maxsynch.period; 547 offset = ti->ti_maxsynch.offset; 548 if (sc->sc_iclkdiv == CLKDIVR_20M) 549 sdp = &ncp_sync_data_20M[0]; 550 else 551 sdp = &ncp_sync_data_40M[0]; 552 553 for (i = 0; sdp->max_period != 0; i ++, sdp ++) 554 { 555 if (period >= sdp->min_period && period <= sdp->max_period) 556 break; 557 } 558 559 if (period != 0 && sdp->max_period == 0) 560 { 561 /* 562 * NO proper period/offset found, 563 * Retry neg with the target. 564 */ 565 ti->ti_maxsynch.period = 0; 566 ti->ti_maxsynch.offset = 0; 567 nti->nti_reg_syncr = 0; 568 nti->nti_reg_ackwidth = 0; 569 error = EINVAL; 570 } 571 else 572 { 573 nti->nti_reg_syncr = (sdp->chip_period << SYNCR_PERS) | 574 (offset & SYNCR_OFFM); 575 nti->nti_reg_ackwidth = sdp->ack_width; 576 error = 0; 577 } 578 579 nsp_cr_write_1(bst, bsh, NSPR_SYNCR, nti->nti_reg_syncr); 580 nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, nti->nti_reg_ackwidth); 581 return error; 582 } 583 584 static int 585 nsp_targ_init(sc, ti, action) 586 struct nsp_softc *sc; 587 struct targ_info *ti; 588 int action; 589 { 590 struct nsp_targ_info *nti = (void *) ti; 591 592 if (action == SCSI_LOW_INFO_ALLOC || action == SCSI_LOW_INFO_REVOKE) 593 { 594 ti->ti_width = SCSI_LOW_BUS_WIDTH_8; 595 ti->ti_maxsynch.period = 100 / 4; 596 ti->ti_maxsynch.offset = 15; 597 nti->nti_reg_syncr = 0; 598 nti->nti_reg_ackwidth = 0; 599 } 600 return 0; 601 } 602 603 static void 604 nsp_start_timer(sc, time) 605 struct nsp_softc *sc; 606 int time; 607 { 608 bus_space_tag_t bst = sc->sc_iot; 609 bus_space_handle_t bsh = sc->sc_ioh; 610 611 sc->sc_timer = time; 612 nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, time); 613 } 614 615 /************************************************************** 616 * General probe attach 617 **************************************************************/ 618 int 619 nspprobesubr(iot, ioh, dvcfg) 620 bus_space_tag_t iot; 621 bus_space_handle_t ioh; 622 u_int dvcfg; 623 { 624 u_int8_t regv; 625 626 regv = bus_space_read_1(iot, ioh, nsp_fifosr); 627 if (regv < 0x11 || regv >= 0x20) 628 return 0; 629 return 1; 630 } 631 632 int 633 nspprint(aux, name) 634 void *aux; 635 const char *name; 636 { 637 638 if (name != NULL) 639 printf("%s: scsibus ", name); 640 return UNCONF; 641 } 642 643 void 644 nspattachsubr(sc) 645 struct nsp_softc *sc; 646 { 647 struct scsi_low_softc *slp = &sc->sc_sclow; 648 649 printf("\n"); 650 651 sc->sc_idbit = (1 << slp->sl_hostid); 652 slp->sl_flags |= HW_READ_PADDING; 653 slp->sl_funcs = &nspfuncs; 654 sc->sc_tmaxcnt = SCSI_LOW_MIN_TOUT * 1000 * 1000; /* default */ 655 656 (void) scsi_low_attach(slp, 0, NSP_NTARGETS, NSP_NLUNS, 657 sizeof(struct nsp_targ_info), 0); 658 } 659 660 /************************************************************** 661 * PDMA functions 662 **************************************************************/ 663 static u_int 664 nsp_fifo_count(sc) 665 struct nsp_softc *sc; 666 { 667 bus_space_tag_t bst = sc->sc_iot; 668 bus_space_handle_t bsh = sc->sc_ioh; 669 u_int count; 670 671 nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_RSS_ACK | PTCLRR_PT); 672 count = bus_space_read_1(bst, bsh, nsp_datar); 673 count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 8); 674 count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 16); 675 return count; 676 } 677 678 static u_int 679 nsp_request_count(sc) 680 struct nsp_softc *sc; 681 { 682 bus_space_tag_t bst = sc->sc_iot; 683 bus_space_handle_t bsh = sc->sc_ioh; 684 u_int count; 685 686 nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_RSS_REQ | PTCLRR_PT); 687 count = bus_space_read_1(bst, bsh, nsp_datar); 688 count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 8); 689 count += (((u_int) bus_space_read_1(bst, bsh, nsp_datar)) << 16); 690 return count; 691 } 692 693 static void 694 nsp_setup_fifo(sc, on, direction, datalen) 695 struct nsp_softc *sc; 696 int on; 697 int direction; 698 int datalen; 699 { 700 u_int8_t xfermode; 701 702 sc->sc_suspendio = 0; 703 if (on == NSP_FIFO_OFF) 704 { 705 xfermode = XFERMR_IO8; 706 goto out; 707 } 708 709 /* check if suspend io OK ? */ 710 if (datalen > 0) 711 { 712 if (direction == SCSI_LOW_READ) 713 { 714 if ((nsp_io_control & NSP_READ_SUSPEND_IO) != 0 && 715 (datalen % nsp_read_suspend_bytes) == 0) 716 sc->sc_suspendio = nsp_read_suspend_bytes; 717 } 718 else 719 { 720 if ((nsp_io_control & NSP_WRITE_SUSPEND_IO) != 0 && 721 (datalen % nsp_write_suspend_bytes) == 0) 722 sc->sc_suspendio = nsp_write_suspend_bytes; 723 } 724 } 725 726 /* determine a transfer type */ 727 if (datalen < DEV_BSIZE || (datalen & 3) != 0) 728 { 729 if (sc->sc_memh != 0 && 730 (nsp_io_control & NSP_USE_MEMIO) != 0) 731 xfermode = XFERMR_XEN | XFERMR_MEM8; 732 else 733 xfermode = XFERMR_XEN | XFERMR_IO8; 734 } 735 else 736 { 737 if (sc->sc_memh != 0 && 738 (nsp_io_control & NSP_USE_MEMIO) != 0) 739 xfermode = XFERMR_XEN | XFERMR_MEM32; 740 else 741 xfermode = XFERMR_XEN | XFERMR_IO32; 742 743 if (sc->sc_suspendio > 0) 744 xfermode |= XFERMR_FIFOEN; 745 } 746 747 out: 748 sc->sc_xfermr = xfermode; 749 nsp_cr_write_1(sc->sc_iot, sc->sc_ioh, NSPR_XFERMR, sc->sc_xfermr); 750 } 751 752 static void 753 nsp_pdma_end(sc, ti) 754 struct nsp_softc *sc; 755 struct targ_info *ti; 756 { 757 struct scsi_low_softc *slp = &sc->sc_sclow; 758 struct slccb *cb = slp->sl_Qnexus; 759 u_int len = 0, cnt; 760 761 sc->sc_dataout_timeout = 0; 762 slp->sl_flags &= ~HW_PDMASTART; 763 nsp_setup_fifo(sc, NSP_FIFO_OFF, SCSI_LOW_READ, 0); 764 if ((sc->sc_icr & SCIENR_FIFO) != 0) 765 { 766 sc->sc_icr &= ~SCIENR_FIFO; 767 nsp_cr_write_1(sc->sc_iot, sc->sc_ioh, NSPR_SCIENR, sc->sc_icr); 768 } 769 770 if (cb == NULL) 771 { 772 slp->sl_error |= PDMAERR; 773 return; 774 } 775 776 if (ti->ti_phase == PH_DATA) 777 { 778 cnt = nsp_fifo_count(sc); 779 if (slp->sl_scp.scp_direction == SCSI_LOW_WRITE) 780 { 781 len = sc->sc_cnt - cnt; 782 if (sc->sc_cnt >= cnt && 783 slp->sl_scp.scp_datalen + len <= 784 cb->ccb_scp.scp_datalen) 785 { 786 slp->sl_scp.scp_data -= len; 787 slp->sl_scp.scp_datalen += len; 788 } 789 else 790 { 791 slp->sl_error |= PDMAERR; 792 printf("%s len %x >= datalen %x\n", 793 slp->sl_xname, 794 len, slp->sl_scp.scp_datalen); 795 } 796 } 797 else if (slp->sl_scp.scp_direction == SCSI_LOW_READ) 798 { 799 if (sc->sc_cnt != cnt || 800 sc->sc_cnt > cb->ccb_scp.scp_datalen) 801 { 802 slp->sl_error |= PDMAERR; 803 printf("%s: data read count error %x != %x (%x)\n", 804 slp->sl_xname, sc->sc_cnt, cnt, 805 cb->ccb_scp.scp_datalen); 806 } 807 } 808 sc->sc_cnt = cnt; 809 scsi_low_data_finish(slp); 810 } 811 else 812 { 813 814 printf("%s data phase miss\n", slp->sl_xname); 815 slp->sl_error |= PDMAERR; 816 } 817 } 818 819 #define RFIFO_CRIT 64 820 #define WFIFO_CRIT 32 821 822 static void 823 nsp_data_padding(sc, direction, count) 824 struct nsp_softc *sc; 825 int direction; 826 u_int count; 827 { 828 bus_space_tag_t bst = sc->sc_iot; 829 bus_space_handle_t bsh = sc->sc_ioh; 830 831 if (count > NSP_MAX_DATA_SIZE) 832 count = NSP_MAX_DATA_SIZE; 833 834 nsp_cr_write_1(bst, bsh, NSPR_XFERMR, XFERMR_XEN | XFERMR_IO8); 835 if (direction == SCSI_LOW_READ) 836 { 837 while (count -- > 0) 838 (void) bus_space_read_1(bst, bsh, nsp_fifodr); 839 } 840 else 841 { 842 while (count -- > 0) 843 (void) bus_space_write_1(bst, bsh, nsp_fifodr, 0); 844 } 845 nsp_cr_write_1(bst, bsh, NSPR_XFERMR, sc->sc_xfermr); 846 } 847 848 static int 849 nsp_read_fifo(sc, suspendio) 850 struct nsp_softc *sc; 851 int suspendio; 852 { 853 struct scsi_low_softc *slp = &sc->sc_sclow; 854 bus_space_tag_t bst = sc->sc_iot; 855 bus_space_handle_t bsh = sc->sc_ioh; 856 u_int res; 857 858 res = nsp_fifo_count(sc); 859 if (res == sc->sc_cnt) 860 return 0; 861 862 #ifdef NSP_DEBUG 863 if (res < sc->sc_cnt || res == (u_int) -1) 864 { 865 printf("%s: strange fifo ack count 0x%x < 0x%x\n", 866 slp->sl_xname, res, sc->sc_cnt); 867 return 0; 868 } 869 #endif /* NSP_DEBUG */ 870 871 res = res - sc->sc_cnt; 872 if (res > slp->sl_scp.scp_datalen) 873 { 874 if ((slp->sl_error & PDMAERR) == 0) 875 { 876 printf("%s: data overrun 0x%x > 0x%x\n", 877 slp->sl_xname, res, slp->sl_scp.scp_datalen); 878 } 879 880 slp->sl_error |= PDMAERR; 881 slp->sl_scp.scp_datalen = 0; 882 883 if ((slp->sl_flags & HW_READ_PADDING) == 0) 884 { 885 printf("%s: read padding required\n", slp->sl_xname); 886 return 0; 887 } 888 889 nsp_data_padding(sc, SCSI_LOW_READ, res); 890 sc->sc_cnt += res; 891 return 1; /* padding start */ 892 } 893 894 if (suspendio > 0 && slp->sl_scp.scp_datalen >= suspendio) 895 res = suspendio; 896 897 if ((sc->sc_xfermr & (XFERMR_MEM32 | XFERMR_MEM8)) != 0) 898 { 899 if ((sc->sc_xfermr & XFERMR_MEM32) != 0) 900 { 901 res &= ~3; 902 bus_space_read_region_4(sc->sc_memt, sc->sc_memh, 0, 903 (u_int32_t *) slp->sl_scp.scp_data, res >> 2); 904 } 905 else 906 { 907 bus_space_read_region_1(sc->sc_memt, sc->sc_memh, 0, 908 (u_int8_t *) slp->sl_scp.scp_data, res); 909 } 910 } 911 else 912 { 913 if ((sc->sc_xfermr & XFERMR_IO32) != 0) 914 { 915 res &= ~3; 916 bus_space_read_multi_4(bst, bsh, nsp_fifodr, 917 (u_int32_t *) slp->sl_scp.scp_data, res >> 2); 918 } 919 else 920 { 921 bus_space_read_multi_1(bst, bsh, nsp_fifodr, 922 (u_int8_t *) slp->sl_scp.scp_data, res); 923 } 924 } 925 926 if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE) 927 { 928 nsp_cr_write_1(bst, bsh, NSPR_PARITYR, 929 PARITYR_ENABLE | PARITYR_CLEAR); 930 scsi_low_assert_msg(slp, slp->sl_Tnexus, SCSI_LOW_MSG_ERROR, 1); 931 } 932 933 slp->sl_scp.scp_data += res; 934 slp->sl_scp.scp_datalen -= res; 935 sc->sc_cnt += res; 936 return 0; 937 } 938 939 static int 940 nsp_write_fifo(sc, suspendio) 941 struct nsp_softc *sc; 942 int suspendio; 943 { 944 struct scsi_low_softc *slp = &sc->sc_sclow; 945 bus_space_tag_t bst = sc->sc_iot; 946 bus_space_handle_t bsh = sc->sc_ioh; 947 u_int res; 948 register u_int8_t stat; 949 950 if (suspendio > 0) 951 { 952 #ifdef NSP_DEBUG 953 if ((slp->sl_scp.scp_datalen % WFIFO_CRIT) != 0) 954 { 955 printf("%s: strange write length 0x%x\n", 956 slp->sl_xname, slp->sl_scp.scp_datalen); 957 } 958 #endif /* NSP_DEBUG */ 959 res = slp->sl_scp.scp_datalen % suspendio; 960 if (res == 0) 961 { 962 res = suspendio; 963 } 964 } 965 else 966 { 967 res = WFIFO_CRIT; 968 } 969 970 if (res > slp->sl_scp.scp_datalen) 971 res = slp->sl_scp.scp_datalen; 972 973 /* XXX: reconfirm! */ 974 stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON) & SCBUSMON_PHMASK; 975 if (stat != PHASE_DATAOUT) 976 return 0; 977 978 if ((sc->sc_xfermr & (XFERMR_MEM32 | XFERMR_MEM8)) != 0) 979 { 980 if ((sc->sc_xfermr & XFERMR_MEM32) != 0) 981 { 982 bus_space_write_region_4(sc->sc_memt, sc->sc_memh, 0, 983 (u_int32_t *) slp->sl_scp.scp_data, res >> 2); 984 } 985 else 986 { 987 bus_space_write_region_1(sc->sc_memt, sc->sc_memh, 0, 988 (u_int8_t *) slp->sl_scp.scp_data, res); 989 } 990 } 991 else 992 { 993 if ((sc->sc_xfermr & XFERMR_IO32) != 0) 994 { 995 bus_space_write_multi_4(bst, bsh, nsp_fifodr, 996 (u_int32_t *) slp->sl_scp.scp_data, res >> 2); 997 } 998 else 999 { 1000 bus_space_write_multi_1(bst, bsh, nsp_fifodr, 1001 (u_int8_t *) slp->sl_scp.scp_data, res); 1002 } 1003 } 1004 1005 slp->sl_scp.scp_datalen -= res; 1006 slp->sl_scp.scp_data += res; 1007 sc->sc_cnt += res; 1008 return 0; 1009 } 1010 1011 static int 1012 nsp_wait_interrupt(sc) 1013 struct nsp_softc *sc; 1014 { 1015 bus_space_tag_t bst = sc->sc_iot; 1016 bus_space_handle_t bsh = sc->sc_ioh; 1017 int tout; 1018 register u_int8_t isrc; 1019 1020 for (tout = 0; tout < DEV_BSIZE / 10; tout ++) 1021 { 1022 isrc = bus_space_read_1(bst, bsh, nsp_irqsr); 1023 if ((isrc & (IRQSR_SCSI | IRQSR_FIFO)) != 0) 1024 { 1025 if ((isrc & IRQSR_FIFO) != 0) 1026 { 1027 bus_space_write_1(bst, bsh, 1028 nsp_irqcr, IRQCR_FIFOCL); 1029 } 1030 return 1; 1031 } 1032 SCSI_LOW_DELAY(1); 1033 } 1034 return 0; 1035 } 1036 1037 static void 1038 nsp_pio_read(sc, suspendio) 1039 struct nsp_softc *sc; 1040 int suspendio; 1041 { 1042 struct scsi_low_softc *slp = &sc->sc_sclow; 1043 bus_space_tag_t bst = sc->sc_iot; 1044 bus_space_handle_t bsh = sc->sc_ioh; 1045 int tout, padding, datalen; 1046 register u_int8_t stat, fstat; 1047 1048 padding = 0; 1049 tout = sc->sc_tmaxcnt; 1050 slp->sl_flags |= HW_PDMASTART; 1051 datalen = slp->sl_scp.scp_datalen; 1052 1053 ReadLoop: 1054 while (1) 1055 { 1056 stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON); 1057 if (stat == (u_int8_t) -1) 1058 return; 1059 1060 /* out of data phase */ 1061 if ((stat & SCBUSMON_PHMASK) != PHASE_DATAIN) 1062 { 1063 nsp_read_fifo(sc, 0); 1064 return; 1065 } 1066 1067 /* data phase */ 1068 fstat = bus_space_read_1(bst, bsh, nsp_fifosr); 1069 if ((fstat & FIFOSR_FULLEMP) != 0) 1070 { 1071 if ((sc->sc_icr & SCIENR_FIFO) != 0) 1072 { 1073 bus_space_write_1(bst, bsh, nsp_irqcr, 1074 IRQCR_FIFOCL); 1075 } 1076 1077 if (suspendio > 0) 1078 { 1079 padding |= nsp_read_fifo(sc, suspendio); 1080 } 1081 else 1082 { 1083 padding |= nsp_read_fifo(sc, 0); 1084 } 1085 1086 if ((sc->sc_icr & SCIENR_FIFO) != 0) 1087 break; 1088 } 1089 else 1090 { 1091 if (padding == 0 && slp->sl_scp.scp_datalen <= 0) 1092 return; 1093 1094 if ((sc->sc_icr & SCIENR_FIFO) != 0) 1095 break; 1096 1097 SCSI_LOW_DELAY(1); 1098 } 1099 1100 if ((-- tout) <= 0) 1101 { 1102 printf("%s: nsp_pio_read: timeout\n", slp->sl_xname); 1103 return; 1104 } 1105 } 1106 1107 1108 if (slp->sl_scp.scp_datalen > 0 && 1109 slp->sl_scp.scp_datalen > datalen - nsp_read_interrupt_bytes) 1110 { 1111 if (nsp_wait_interrupt(sc) != 0) 1112 goto ReadLoop; 1113 } 1114 } 1115 1116 static void 1117 nsp_pio_write(sc, suspendio) 1118 struct nsp_softc *sc; 1119 int suspendio; 1120 { 1121 struct scsi_low_softc *slp = &sc->sc_sclow; 1122 bus_space_tag_t bst = sc->sc_iot; 1123 bus_space_handle_t bsh = sc->sc_ioh; 1124 u_int rcount, acount; 1125 int tout, datalen; 1126 register u_int8_t stat, fstat; 1127 1128 tout = sc->sc_tmaxcnt; 1129 slp->sl_flags |= HW_PDMASTART; 1130 datalen = slp->sl_scp.scp_datalen; 1131 1132 WriteLoop: 1133 while (1) 1134 { 1135 stat = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON) & SCBUSMON_PHMASK; 1136 if (stat != PHASE_DATAOUT) 1137 return; 1138 1139 if (slp->sl_scp.scp_datalen <= 0) 1140 { 1141 if (sc->sc_dataout_timeout == 0) 1142 sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ; 1143 return; 1144 } 1145 1146 fstat = bus_space_read_1(bst, bsh, nsp_fifosr); 1147 if ((fstat & FIFOSR_FULLEMP) != 0) 1148 { 1149 if ((sc->sc_icr & SCIENR_FIFO) != 0) 1150 { 1151 bus_space_write_1(bst, bsh, nsp_irqcr, 1152 IRQCR_FIFOCL); 1153 } 1154 1155 if (suspendio > 0) 1156 { 1157 /* XXX:IMPORTANT: 1158 * To avoid timeout of pcmcia bus 1159 * (not scsi bus!), we should check 1160 * the scsi device sends us request 1161 * signals, which means the scsi device 1162 * is ready to recieve data without 1163 * heavy delays. 1164 */ 1165 if ((slp->sl_scp.scp_datalen % suspendio) == 0) 1166 { 1167 /* Step I: 1168 * fill the nsp fifo, and waiting for 1169 * the fifo empty. 1170 */ 1171 nsp_write_fifo(sc, 0); 1172 } 1173 else 1174 { 1175 /* Step II: 1176 * check the request singals. 1177 */ 1178 acount = nsp_fifo_count(sc); 1179 rcount = nsp_request_count(sc); 1180 if (rcount <= acount) 1181 { 1182 nsp_write_fifo(sc, 0); 1183 #ifdef NSP_STATICS 1184 nsp_statics.device_busy ++; 1185 #endif /* NSP_STATICS */ 1186 } 1187 else 1188 { 1189 nsp_write_fifo(sc, suspendio); 1190 #ifdef NSP_STATICS 1191 nsp_statics.device_data_write ++; 1192 #endif /* NSP_STATICS */ 1193 } 1194 } 1195 } 1196 else 1197 { 1198 nsp_write_fifo(sc, 0); 1199 } 1200 1201 if ((sc->sc_icr & SCIENR_FIFO) != 0) 1202 break; 1203 } 1204 else 1205 { 1206 if ((sc->sc_icr & SCIENR_FIFO) != 0) 1207 break; 1208 1209 SCSI_LOW_DELAY(1); 1210 } 1211 1212 if ((-- tout) <= 0) 1213 { 1214 printf("%s: nsp_pio_write: timeout\n", slp->sl_xname); 1215 return; 1216 } 1217 } 1218 1219 if (slp->sl_scp.scp_datalen > 0 && 1220 slp->sl_scp.scp_datalen > datalen - nsp_write_interrupt_bytes) 1221 { 1222 if (nsp_wait_interrupt(sc) != 0) 1223 goto WriteLoop; 1224 } 1225 } 1226 1227 static int 1228 nsp_negate_signal(sc, mask, s) 1229 struct nsp_softc *sc; 1230 u_int8_t mask; 1231 u_char *s; 1232 { 1233 struct scsi_low_softc *slp = &sc->sc_sclow; 1234 bus_space_tag_t bst = sc->sc_iot; 1235 bus_space_handle_t bsh = sc->sc_ioh; 1236 int wc; 1237 u_int8_t regv; 1238 1239 for (wc = 0; wc < NSP_DELAY_MAX / NSP_DELAY_INTERVAL; wc ++) 1240 { 1241 regv = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON); 1242 if (regv == (u_int8_t) -1) 1243 return -1; 1244 if ((regv & mask) == 0) 1245 return 1; 1246 SCSI_LOW_DELAY(NSP_DELAY_INTERVAL); 1247 } 1248 1249 printf("%s: %s nsp_negate_signal timeout\n", slp->sl_xname, s); 1250 return -1; 1251 } 1252 1253 static int 1254 nsp_xfer(sc, buf, len, phase, clear_atn) 1255 struct nsp_softc *sc; 1256 u_int8_t *buf; 1257 int len; 1258 int phase; 1259 int clear_atn; 1260 { 1261 bus_space_tag_t bst = sc->sc_iot; 1262 bus_space_handle_t bsh = sc->sc_ioh; 1263 int ptr, rv; 1264 1265 for (ptr = 0; len > 0; len --, ptr ++) 1266 { 1267 rv = nsp_expect_signal(sc, phase, SCBUSMON_REQ); 1268 if (rv <= 0) 1269 goto out; 1270 1271 if (len == 1 && clear_atn != 0) 1272 { 1273 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 1274 SCBUSCR_ADIR | SCBUSCR_ACKEN); 1275 SCSI_LOW_DEASSERT_ATN(&sc->sc_sclow); 1276 } 1277 1278 if (phase & SCBUSMON_IO) 1279 { 1280 buf[ptr] = nsp_cr_read_1(bst, bsh, NSPR_DATAACK); 1281 } 1282 else 1283 { 1284 nsp_cr_write_1(bst, bsh, NSPR_DATAACK, buf[ptr]); 1285 } 1286 nsp_negate_signal(sc, SCBUSMON_ACK, "xfer<ACK>"); 1287 } 1288 1289 out: 1290 return len; 1291 } 1292 1293 /************************************************************** 1294 * disconnect & reselect (HW low) 1295 **************************************************************/ 1296 static int 1297 nsp_reselected(sc) 1298 struct nsp_softc *sc; 1299 { 1300 struct scsi_low_softc *slp = &sc->sc_sclow; 1301 bus_space_tag_t bst = sc->sc_iot; 1302 bus_space_handle_t bsh = sc->sc_ioh; 1303 struct targ_info *ti; 1304 u_int sid; 1305 u_int8_t cr; 1306 1307 sid = (u_int) nsp_cr_read_1(bst, bsh, NSPR_RESELR); 1308 sid &= ~sc->sc_idbit; 1309 sid = ffs(sid) - 1; 1310 if ((ti = scsi_low_reselected(slp, sid)) == NULL) 1311 return EJUSTRETURN; 1312 1313 nsp_negate_signal(sc, SCBUSMON_SEL, "reselect<SEL>"); 1314 1315 cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR); 1316 cr &= ~(SCBUSCR_BSY | SCBUSCR_ATN); 1317 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr); 1318 cr |= SCBUSCR_ADIR | SCBUSCR_ACKEN; 1319 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr); 1320 1321 #ifdef NSP_STATICS 1322 nsp_statics.reselect ++; 1323 #endif /* NSP_STATCIS */ 1324 return EJUSTRETURN; 1325 } 1326 1327 static int 1328 nsp_disconnected(sc, ti) 1329 struct nsp_softc *sc; 1330 struct targ_info *ti; 1331 { 1332 struct scsi_low_softc *slp = &sc->sc_sclow; 1333 bus_space_tag_t bst = sc->sc_iot; 1334 bus_space_handle_t bsh = sc->sc_ioh; 1335 1336 nsp_cr_write_1(bst, bsh, NSPR_PTCLRR, PTCLRR_PT | PTCLRR_ACK | 1337 PTCLRR_REQ | PTCLRR_HOST); 1338 if ((sc->sc_icr & SCIENR_FIFO) != 0) 1339 { 1340 sc->sc_icr &= ~SCIENR_FIFO; 1341 nsp_cr_write_1(bst, bsh, NSPR_SCIENR, sc->sc_icr); 1342 } 1343 sc->sc_cnt = 0; 1344 sc->sc_dataout_timeout = 0; 1345 #ifdef NSP_STATICS 1346 nsp_statics.disconnect ++; 1347 #endif /* NSP_STATICS */ 1348 scsi_low_disconnected(slp, ti); 1349 return 1; 1350 } 1351 1352 /************************************************************** 1353 * SEQUENCER 1354 **************************************************************/ 1355 static void nsp_error(struct nsp_softc *, u_char *, u_int8_t, u_int8_t, u_int8_t); 1356 1357 static void 1358 nsp_error(sc, s, isrc, ph, irqphs) 1359 struct nsp_softc *sc; 1360 u_char *s; 1361 u_int8_t isrc, ph, irqphs; 1362 { 1363 struct scsi_low_softc *slp = &sc->sc_sclow; 1364 1365 printf("%s: %s\n", slp->sl_xname, s); 1366 printf("%s: isrc 0x%x scmon 0x%x irqphs 0x%x\n", 1367 slp->sl_xname, (u_int) isrc, (u_int) ph, (u_int) irqphs); 1368 } 1369 1370 static int 1371 nsp_target_nexus_establish(sc) 1372 struct nsp_softc *sc; 1373 { 1374 struct scsi_low_softc *slp = &sc->sc_sclow; 1375 bus_space_tag_t bst = sc->sc_iot; 1376 bus_space_handle_t bsh = sc->sc_ioh; 1377 struct targ_info *ti = slp->sl_Tnexus; 1378 struct nsp_targ_info *nti = (void *) ti; 1379 1380 /* setup synch transfer registers */ 1381 nsp_cr_write_1(bst, bsh, NSPR_SYNCR, nti->nti_reg_syncr); 1382 nsp_cr_write_1(bst, bsh, NSPR_ACKWIDTH, nti->nti_reg_ackwidth); 1383 1384 /* setup pdma fifo (minimum) */ 1385 nsp_setup_fifo(sc, NSP_FIFO_ON, SCSI_LOW_READ, 0); 1386 return 0; 1387 } 1388 1389 static int 1390 nsp_lun_nexus_establish(sc) 1391 struct nsp_softc *sc; 1392 { 1393 1394 return 0; 1395 } 1396 1397 static int 1398 nsp_ccb_nexus_establish(sc) 1399 struct nsp_softc *sc; 1400 { 1401 struct scsi_low_softc *slp = &sc->sc_sclow; 1402 struct slccb *cb = slp->sl_Qnexus; 1403 1404 sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000; 1405 1406 /* setup pdma fifo */ 1407 nsp_setup_fifo(sc, NSP_FIFO_ON, 1408 slp->sl_scp.scp_direction, slp->sl_scp.scp_datalen); 1409 1410 if (slp->sl_scp.scp_direction == SCSI_LOW_READ) 1411 { 1412 if (sc->sc_suspendio > 0 && 1413 (nsp_io_control & NSP_READ_FIFO_INTERRUPTS) != 0) 1414 { 1415 sc->sc_icr |= SCIENR_FIFO; 1416 nsp_cr_write_1(sc->sc_iot, sc->sc_ioh, 1417 NSPR_SCIENR, sc->sc_icr); 1418 } 1419 } 1420 else 1421 { 1422 if (sc->sc_suspendio > 0 && 1423 (nsp_io_control & NSP_WRITE_FIFO_INTERRUPTS) != 0) 1424 { 1425 sc->sc_icr |= SCIENR_FIFO; 1426 nsp_cr_write_1(sc->sc_iot, sc->sc_ioh, 1427 NSPR_SCIENR, sc->sc_icr); 1428 } 1429 } 1430 return 0; 1431 } 1432 1433 static int 1434 nsp_phase_match(sc, phase, stat) 1435 struct nsp_softc *sc; 1436 u_int8_t phase; 1437 u_int8_t stat; 1438 { 1439 struct scsi_low_softc *slp = &sc->sc_sclow; 1440 1441 if ((stat & SCBUSMON_PHMASK) != phase) 1442 { 1443 printf("%s: phase mismatch 0x%x != 0x%x\n", 1444 slp->sl_xname, (u_int) phase, (u_int) stat); 1445 return EINVAL; 1446 } 1447 1448 if ((stat & SCBUSMON_REQ) == 0) 1449 return EINVAL; 1450 1451 return 0; 1452 } 1453 1454 int 1455 nspintr(arg) 1456 void *arg; 1457 { 1458 struct nsp_softc *sc = arg; 1459 struct scsi_low_softc *slp = &sc->sc_sclow; 1460 bus_space_tag_t bst = sc->sc_iot; 1461 bus_space_handle_t bsh = sc->sc_ioh; 1462 struct targ_info *ti; 1463 struct physio_proc *pp; 1464 struct buf *bp; 1465 u_int derror, flags; 1466 int len, rv; 1467 u_int8_t isrc, ph, irqphs, cr, regv; 1468 1469 /******************************************* 1470 * interrupt check 1471 *******************************************/ 1472 if (slp->sl_flags & HW_INACTIVE) 1473 return 0; 1474 1475 bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_IRQDIS); 1476 isrc = bus_space_read_1(bst, bsh, nsp_irqsr); 1477 if (isrc == (u_int8_t) -1 || (isrc & IRQSR_MASK) == 0) 1478 { 1479 bus_space_write_1(bst, bsh, nsp_irqcr, 0); 1480 return 0; 1481 } 1482 1483 /* XXX: IMPORTANT 1484 * Do not read an irqphs register if no scsi phase interrupt. 1485 * Unless, you should lose a scsi phase interrupt. 1486 */ 1487 ph = nsp_cr_read_1(bst, bsh, NSPR_SCBUSMON); 1488 if ((isrc & IRQSR_SCSI) != 0) 1489 { 1490 irqphs = nsp_cr_read_1(bst, bsh, NSPR_IRQPHS); 1491 } 1492 else 1493 irqphs = 0; 1494 1495 /* 1496 * timer interrupt handler (scsi vs timer interrupts) 1497 */ 1498 if (sc->sc_timer != 0) 1499 { 1500 nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0); 1501 nsp_cr_write_1(bst, bsh, NSPR_TIMERCNT, 0); 1502 sc->sc_timer = 0; 1503 } 1504 1505 /* check a timer interrupt */ 1506 regv = 0; 1507 if ((isrc & IRQSR_TIMER) != 0) 1508 { 1509 if ((isrc & IRQSR_MASK) == IRQSR_TIMER && sc->sc_seltout == 0) 1510 { 1511 bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_TIMERCL); 1512 return 1; 1513 } 1514 regv |= IRQCR_TIMERCL; 1515 } 1516 1517 /* check a fifo interrupt */ 1518 if ((isrc & IRQSR_FIFO) != 0) 1519 { 1520 regv |= IRQCR_FIFOCL; 1521 } 1522 1523 /* OK. enable all interrupts */ 1524 bus_space_write_1(bst, bsh, nsp_irqcr, regv); 1525 1526 /******************************************* 1527 * debug section 1528 *******************************************/ 1529 #ifdef NSP_DEBUG 1530 if (nsp_debug) 1531 { 1532 nsp_error(sc, "current status", isrc, ph, irqphs); 1533 scsi_low_print(slp, NULL); 1534 #ifdef KDB 1535 if (nsp_debug > 1) 1536 SCSI_LOW_DEBUGGER("nsp"); 1537 #endif /* KDB */ 1538 } 1539 #endif /* NSP_DEBUG */ 1540 1541 /******************************************* 1542 * Parse hardware SCSI irq reasons register 1543 *******************************************/ 1544 if ((isrc & IRQSR_SCSI) != 0) 1545 { 1546 if ((irqphs & IRQPHS_RST) != 0) 1547 { 1548 scsi_low_restart(slp, SCSI_LOW_RESTART_SOFT, 1549 "bus reset (power off?)"); 1550 return 1; 1551 } 1552 1553 if ((irqphs & IRQPHS_RSEL) != 0) 1554 { 1555 bus_space_write_1(bst, bsh, nsp_irqcr, IRQCR_RESCL); 1556 if (nsp_reselected(sc) == EJUSTRETURN) 1557 return 1; 1558 } 1559 1560 if ((irqphs & (IRQPHS_PCHG | IRQPHS_LBF)) == 0) 1561 return 1; 1562 } 1563 1564 /******************************************* 1565 * nexus check 1566 *******************************************/ 1567 if ((ti = slp->sl_Tnexus) == NULL) 1568 { 1569 /* unknown scsi phase changes */ 1570 nsp_error(sc, "unknown scsi phase changes", isrc, ph, irqphs); 1571 return 0; 1572 } 1573 1574 /******************************************* 1575 * aribitration & selection 1576 *******************************************/ 1577 switch (ti->ti_phase) 1578 { 1579 case PH_SELSTART: 1580 if ((ph & SCBUSMON_BSY) == 0) 1581 { 1582 if (sc->sc_seltout >= NSP_SELTIMEOUT) 1583 { 1584 sc->sc_seltout = 0; 1585 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, 0); 1586 return nsp_disconnected(sc, ti); 1587 } 1588 sc->sc_seltout ++; 1589 nsp_start_timer(sc, NSP_TIMER_1MS); 1590 return 1; 1591 } 1592 1593 SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED); 1594 nsphw_selection_done_and_expect_msgout(sc); 1595 return 1; 1596 1597 case PH_SELECTED: 1598 if ((isrc & IRQSR_SCSI) == 0) 1599 return 1; 1600 1601 nsp_target_nexus_establish(sc); 1602 break; 1603 1604 case PH_RESEL: 1605 if ((isrc & IRQSR_SCSI) == 0) 1606 return 1; 1607 1608 nsp_target_nexus_establish(sc); 1609 if ((ph & SCBUSMON_PHMASK) != PHASE_MSGIN) 1610 { 1611 printf("%s: unexpected phase after reselect\n", 1612 slp->sl_xname); 1613 slp->sl_error |= FATALIO; 1614 scsi_low_assert_msg(slp, ti, SCSI_LOW_MSG_ABORT, 1); 1615 return 1; 1616 } 1617 break; 1618 1619 case PH_DATA: 1620 if ((isrc & IRQSR_SCSI) != 0) 1621 break; 1622 if ((isrc & IRQSR_FIFO) != 0) 1623 { 1624 if (NSP_IS_PHASE_DATA(ph) == 0) 1625 return 1; 1626 irqphs = (ph & IRQPHS_PHMASK); 1627 break; 1628 } 1629 return 1; 1630 1631 default: 1632 if ((isrc & IRQSR_SCSI) == 0) 1633 return 1; 1634 break; 1635 } 1636 1637 /******************************************* 1638 * data phase control 1639 *******************************************/ 1640 if (slp->sl_flags & HW_PDMASTART) 1641 { 1642 if ((isrc & IRQSR_SCSI) != 0 && 1643 NSP_IS_IRQPHS_DATA(irqphs) == 0) 1644 { 1645 if (slp->sl_scp.scp_direction == SCSI_LOW_READ) 1646 nsp_pio_read(sc, 0); 1647 nsp_pdma_end(sc, ti); 1648 } 1649 } 1650 1651 /******************************************* 1652 * scsi seq 1653 *******************************************/ 1654 if (slp->sl_msgphase != 0 && (irqphs & IRQPHS_LBF) != 0) 1655 return nsp_disconnected(sc, ti); 1656 1657 /* check unexpected bus free state */ 1658 if (ph == 0) 1659 { 1660 nsp_error(sc, "unexpected bus free", isrc, ph, irqphs); 1661 return nsp_disconnected(sc, ti); 1662 } 1663 1664 /* check normal scsi phase */ 1665 switch (irqphs & IRQPHS_PHMASK) 1666 { 1667 case IRQPHS_CMD: 1668 if (nsp_phase_match(sc, PHASE_CMD, ph) != 0) 1669 return 1; 1670 1671 SCSI_LOW_SETUP_PHASE(ti, PH_CMD); 1672 if (scsi_low_cmd(slp, ti) != 0) 1673 { 1674 scsi_low_attention(slp); 1675 } 1676 1677 nsp_cr_write_1(bst, bsh, NSPR_CMDCR, CMDCR_PTCLR); 1678 for (len = 0; len < slp->sl_scp.scp_cmdlen; len ++) 1679 nsp_cr_write_1(bst, bsh, NSPR_CMDDR, 1680 slp->sl_scp.scp_cmd[len]); 1681 1682 nsp_cr_write_1(bst, bsh, NSPR_CMDCR, CMDCR_PTCLR | CMDCR_EXEC); 1683 break; 1684 1685 case IRQPHS_DATAOUT: 1686 SCSI_LOW_SETUP_PHASE(ti, PH_DATA); 1687 if (scsi_low_data(slp, ti, &bp, SCSI_LOW_WRITE) != 0) 1688 { 1689 scsi_low_attention(slp); 1690 } 1691 1692 pp = physio_proc_enter(bp); 1693 nsp_pio_write(sc, sc->sc_suspendio); 1694 physio_proc_leave(pp); 1695 break; 1696 1697 case IRQPHS_DATAIN: 1698 SCSI_LOW_SETUP_PHASE(ti, PH_DATA); 1699 if (scsi_low_data(slp, ti, &bp, SCSI_LOW_READ) != 0) 1700 { 1701 scsi_low_attention(slp); 1702 } 1703 1704 pp = physio_proc_enter(bp); 1705 nsp_pio_read(sc, sc->sc_suspendio); 1706 physio_proc_leave(pp); 1707 break; 1708 1709 case IRQPHS_STATUS: 1710 if (nsp_phase_match(sc, PHASE_STATUS, ph) != 0) 1711 return 1; 1712 1713 SCSI_LOW_SETUP_PHASE(ti, PH_STAT); 1714 regv = nsp_cr_read_1(bst, bsh, NSPR_DATA); 1715 if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE) 1716 { 1717 nsp_cr_write_1(bst, bsh, NSPR_PARITYR, 1718 PARITYR_ENABLE | PARITYR_CLEAR); 1719 derror = SCSI_LOW_DATA_PE; 1720 } 1721 else 1722 derror = 0; 1723 1724 /* assert ACK */ 1725 cr = SCBUSCR_ACK | nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR); 1726 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr); 1727 1728 if (scsi_low_statusin(slp, ti, derror | regv) != 0) 1729 { 1730 scsi_low_attention(slp); 1731 } 1732 1733 /* check REQ nagated */ 1734 nsp_negate_signal(sc, SCBUSMON_REQ, "statin<REQ>"); 1735 1736 /* deassert ACK */ 1737 cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) & (~SCBUSCR_ACK); 1738 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr); 1739 break; 1740 1741 case IRQPHS_MSGOUT: 1742 if (nsp_phase_match(sc, PHASE_MSGOUT, ph) != 0) 1743 return 1; 1744 1745 #ifdef NSP_MSGOUT_SERIALIZE 1746 /* 1747 * XXX: NSP QUIRK 1748 * NSP invoke interrupts only in the case of scsi phase changes, 1749 * therefore we should poll the scsi phase here to catch 1750 * the next "msg out" if exists (no scsi phase changes). 1751 */ 1752 rv = len = 16; 1753 do { 1754 SCSI_LOW_SETUP_PHASE(ti, PH_MSGOUT); 1755 flags = (ti->ti_ophase != ti->ti_phase) ? 1756 SCSI_LOW_MSGOUT_INIT : 0; 1757 len = scsi_low_msgout(slp, ti, flags); 1758 1759 if (len > 1 && slp->sl_atten == 0) 1760 { 1761 scsi_low_attention(slp); 1762 } 1763 1764 if (nsp_xfer(sc, ti->ti_msgoutstr, len, PHASE_MSGOUT, 1765 slp->sl_clear_atten) != 0) 1766 { 1767 slp->sl_error |= FATALIO; 1768 nsp_error(sc, "MSGOUT: xfer short", 1769 isrc, ph, irqphs); 1770 } 1771 1772 /* catch a next signal */ 1773 rv = nsp_expect_signal(sc, PHASE_MSGOUT, SCBUSMON_REQ); 1774 } 1775 while (rv > 0 && len -- > 0); 1776 1777 #else /* !NSP_MSGOUT_SERIALIZE */ 1778 SCSI_LOW_SETUP_PHASE(ti, PH_MSGOUT); 1779 flags = SCSI_LOW_MSGOUT_UNIFY; 1780 if (ti->ti_ophase != ti->ti_phase) 1781 flags |= SCSI_LOW_MSGOUT_INIT; 1782 len = scsi_low_msgout(slp, ti, flags); 1783 1784 if (len > 1 && slp->sl_atten == 0) 1785 { 1786 scsi_low_attention(slp); 1787 } 1788 1789 if (nsp_xfer(sc, ti->ti_msgoutstr, len, PHASE_MSGOUT, 1790 slp->sl_clear_atten) != 0) 1791 { 1792 nsp_error(sc, "MSGOUT: xfer short", isrc, ph, irqphs); 1793 } 1794 1795 #endif /* !NSP_MSGOUT_SERIALIZE */ 1796 break; 1797 1798 case IRQPHS_MSGIN: 1799 if (nsp_phase_match(sc, PHASE_MSGIN, ph) != 0) 1800 return 1; 1801 1802 /* 1803 * XXX: NSP QUIRK 1804 * NSP invoke interrupts only in the case of scsi phase changes, 1805 * therefore we should poll the scsi phase here to catch 1806 * the next "msg in" if exists (no scsi phase changes). 1807 */ 1808 rv = len = 16; 1809 do { 1810 SCSI_LOW_SETUP_PHASE(ti, PH_MSGIN); 1811 1812 /* read a data */ 1813 regv = nsp_cr_read_1(bst, bsh, NSPR_DATA); 1814 if (nsp_cr_read_1(bst, bsh, NSPR_PARITYR) & PARITYR_PE) 1815 { 1816 nsp_cr_write_1(bst, bsh, 1817 NSPR_PARITYR, 1818 PARITYR_ENABLE | PARITYR_CLEAR); 1819 derror = SCSI_LOW_DATA_PE; 1820 } 1821 else 1822 { 1823 derror = 0; 1824 } 1825 1826 /* assert ack */ 1827 cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) | SCBUSCR_ACK; 1828 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr); 1829 1830 if (scsi_low_msgin(slp, ti, regv | derror) == 0) 1831 { 1832 if (scsi_low_is_msgout_continue(ti, 0) != 0) 1833 { 1834 scsi_low_attention(slp); 1835 } 1836 } 1837 1838 /* check REQ nagated */ 1839 nsp_negate_signal(sc, SCBUSMON_REQ, "msgin<REQ>"); 1840 1841 /* deassert ack */ 1842 cr = nsp_cr_read_1(bst, bsh, NSPR_SCBUSCR) & (~SCBUSCR_ACK); 1843 nsp_cr_write_1(bst, bsh, NSPR_SCBUSCR, cr); 1844 1845 /* catch a next signal */ 1846 rv = nsp_expect_signal(sc, PHASE_MSGIN, SCBUSMON_REQ); 1847 } 1848 while (rv > 0 && len -- > 0); 1849 break; 1850 1851 default: 1852 slp->sl_error |= FATALIO; 1853 nsp_error(sc, "unknown scsi phase", isrc, ph, irqphs); 1854 break; 1855 } 1856 1857 return 1; 1858 1859 #if 0 1860 timerout: 1861 nsp_start_timer(sc, NSP_TIMER_1MS); 1862 return 0; 1863 #endif 1864 } 1865 1866 static int 1867 nsp_timeout(sc) 1868 struct nsp_softc *sc; 1869 { 1870 struct scsi_low_softc *slp = &sc->sc_sclow; 1871 bus_space_tag_t iot = sc->sc_iot; 1872 bus_space_handle_t ioh = sc->sc_ioh; 1873 int tout; 1874 u_int8_t ph, regv; 1875 1876 if (slp->sl_Tnexus == NULL) 1877 return 0; 1878 1879 ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON); 1880 switch (ph & SCBUSMON_PHMASK) 1881 { 1882 case PHASE_DATAOUT: 1883 if (sc->sc_dataout_timeout == 0) 1884 break; 1885 1886 /* check a fifo empty */ 1887 regv = bus_space_read_1(iot, ioh, nsp_fifosr); 1888 if ((regv & FIFOSR_FULLEMP) == 0) 1889 break; 1890 bus_space_write_1(iot, ioh, nsp_irqcr, IRQCR_FIFOCL); 1891 1892 /* check still requested */ 1893 ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON); 1894 if ((ph & SCBUSMON_REQ) == 0) 1895 break; 1896 /* check timeout */ 1897 if ((-- sc->sc_dataout_timeout) > 0) 1898 break; 1899 1900 slp->sl_error |= PDMAERR; 1901 if ((slp->sl_flags & HW_WRITE_PADDING) == 0) 1902 { 1903 printf("%s: write padding required\n", slp->sl_xname); 1904 break; 1905 } 1906 1907 tout = NSP_DELAY_MAX; 1908 while (tout -- > 0) 1909 { 1910 ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON); 1911 if ((ph & SCBUSMON_PHMASK) != PHASE_DATAOUT) 1912 break; 1913 regv = bus_space_read_1(iot, ioh, nsp_fifosr); 1914 if ((regv & FIFOSR_FULLEMP) == 0) 1915 { 1916 SCSI_LOW_DELAY(1); 1917 continue; 1918 } 1919 1920 bus_space_write_1(iot, ioh, nsp_irqcr, IRQCR_FIFOCL); 1921 nsp_data_padding(sc, SCSI_LOW_WRITE, 32); 1922 } 1923 ph = nsp_cr_read_1(iot, ioh, NSPR_SCBUSMON); 1924 if ((ph & SCBUSMON_PHMASK) == PHASE_DATAOUT) 1925 sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ; 1926 break; 1927 1928 default: 1929 break; 1930 } 1931 return 0; 1932 }
Cache object: 1b3c5e52a0e1b97d336ad245558bd597
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]