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