sys/dev/stg/tmc18c30.c

   1 /*      $NecBSD: tmc18c30.c,v 1.28.12.3 2001/06/19 04:35:48 honda Exp $ */
   2 /*      $NetBSD$        */
   3
   4 #define STG_DEBUG
   5 #define STG_STATICS
   6 #define STG_IO_CONTROL_FLAGS    (STG_FIFO_INTERRUPTS | STG_WAIT_FOR_SELECT)
   7
   8 /*-
   9  * [NetBSD for NEC PC-98 series]
  10  *  Copyright (c) 1996, 1997, 1998, 1999, 2000, 2001
  11  *      NetBSD/pc98 porting staff. All rights reserved.
  12  *  Copyright (c) 1996, 1997, 1998, 1999, 2000, 2001
  13  *      Naofumi HONDA. All rights reserved.
  14  *  Copyright (c) 1996, 1997, 1998, 1999
  15  *      Kouichi Matsuda. All rights reserved.
  16  *
  17  *  Redistribution and use in source and binary forms, with or without
  18  *  modification, are permitted provided that the following conditions
  19  *  are met:
  20  *  1. Redistributions of source code must retain the above copyright
  21  *     notice, this list of conditions and the following disclaimer.
  22  *  2. Redistributions in binary form must reproduce the above copyright
  23  *     notice, this list of conditions and the following disclaimer in the
  24  *     documentation and/or other materials provided with the distribution.
  25  *  3. The name of the author may not be used to endorse or promote products
  26  *     derived from this software without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  29  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  30  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  31  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  32  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  33  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  34  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  36  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  37  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40
  41 #include <sys/cdefs.h>
  42 __FBSDID("$FreeBSD$");
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/kernel.h>
  47 #if defined(__FreeBSD__) && __FreeBSD_version >= 500001
  48 #include <sys/bio.h>
  49 #endif  /* __FreeBSD__ */
  50 #include <sys/buf.h>
  51 #include <sys/queue.h>
  52 #include <sys/malloc.h>
  53 #include <sys/errno.h>
  54
  55 #ifdef __NetBSD__
  56 #include <sys/device.h>
  57 #include <machine/bus.h>
  58 #include <machine/intr.h>
  59
  60 #include <dev/scsipi/scsi_all.h>
  61 #include <dev/scsipi/scsipi_all.h>
  62 #include <dev/scsipi/scsiconf.h>
  63 #include <dev/scsipi/scsi_disk.h>
  64
  65 #include <machine/dvcfg.h>
  66 #include <machine/physio_proc.h>
  67
  68 #include <i386/Cbus/dev/scsi_low.h>
  69 #include <i386/Cbus/dev/tmc18c30reg.h>
  70 #include <i386/Cbus/dev/tmc18c30var.h>
  71 #endif /* __NetBSD__ */
  72
  73 #ifdef __FreeBSD__
  74 #include <machine/cpu.h>
  75 #include <machine/bus.h>
  76
  77 #include <compat/netbsd/dvcfg.h>
  78 #include <compat/netbsd/physio_proc.h>
  79
  80 #include <cam/scsi/scsi_low.h>
  81 #include <dev/stg/tmc18c30reg.h>
  82 #include <dev/stg/tmc18c30var.h>
  83 #endif /* __FreeBSD__ */
  84
  85 /***************************************************
  86  * USER SETTINGS
  87  ***************************************************/
  88 /* DEVICE CONFIGURATION FLAGS (MINOR)
  89  *
  90  * 0x01   DISCONECT OFF
  91  * 0x02   PARITY LINE OFF
  92  * 0x04   IDENTIFY MSG OFF ( = single lun)
  93  * 0x08   SYNC TRANSFER OFF
  94  */
  95 /* #define      STG_SYNC_SUPPORT */     /* NOT YET but easy */
  96
  97 /* For the 512 fifo type: change below */
  98 #define TMC18C30_FIFOSZ 0x800
  99 #define TMC18C30_FCBSZ  0x200
 100 #define TMC18C50_FIFOSZ 0x2000
 101 #define TMC18C50_FCBSZ  0x400
 102
 103 #define STG_MAX_DATA_SIZE       (64 * 1024)
 104 #define STG_DELAY_MAX                   (2 * 1000 * 1000)
 105 #define STG_DELAY_INTERVAL              (1)
 106 #define STG_DELAY_SELECT_POLLING_MAX    (5 * 1000 * 1000)
 107
 108 /***************************************************
 109  * PARAMS
 110  ***************************************************/
 111 #define STG_NTARGETS    8
 112 #define STG_NLUNS       8
 113
 114 /***************************************************
 115  * DEBUG
 116  ***************************************************/
 117 #ifdef  STG_DEBUG
 118 static int stg_debug;
 119 #endif  /* STG_DEBUG */
 120
 121 #ifdef  STG_STATICS
 122 static struct stg_statics {
 123         int arbit_fail_0;
 124         int arbit_fail_1;
 125         int disconnect;
 126         int reselect;
 127 } stg_statics;
 128 #endif  /* STG_STATICS */
 129
 130 /***************************************************
 131  * IO control flags
 132  ***************************************************/
 133 #define STG_FIFO_INTERRUPTS     0x0001
 134 #define STG_WAIT_FOR_SELECT     0x0100
 135
 136 int stg_io_control = STG_IO_CONTROL_FLAGS;
 137
 138 /***************************************************
 139  * DEVICE STRUCTURE
 140  ***************************************************/
 141 extern struct cfdriver stg_cd;
 142
 143 /**************************************************************
 144  * DECLARE
 145  **************************************************************/
 146 /* static */
 147 static void stg_pio_read(struct stg_softc *, struct targ_info *, u_int);
 148 static void stg_pio_write(struct stg_softc *, struct targ_info *, u_int);
 149 static int stg_xfer(struct stg_softc *, u_int8_t *, int, int, int);
 150 static int stg_msg(struct stg_softc *, struct targ_info *, u_int);
 151 static int stg_reselected(struct stg_softc *);
 152 static int stg_disconnected(struct stg_softc *, struct targ_info *);
 153 static __inline void stg_pdma_end(struct stg_softc *, struct targ_info *);
 154 static int stghw_select_targ_wait(struct stg_softc *, int);
 155 static int stghw_check(struct stg_softc *);
 156 static void stghw_init(struct stg_softc *);
 157 static int stg_negate_signal(struct stg_softc *, u_int8_t, u_char *);
 158 static int stg_expect_signal(struct stg_softc *, u_int8_t, u_int8_t);
 159 static int stg_world_start(struct stg_softc *, int);
 160 static int stghw_start_selection(struct stg_softc *sc, struct slccb *);
 161 static void stghw_bus_reset(struct stg_softc *);
 162 static void stghw_attention(struct stg_softc *);
 163 static int stg_target_nexus_establish(struct stg_softc *);
 164 static int stg_lun_nexus_establish(struct stg_softc *);
 165 static int stg_ccb_nexus_establish(struct stg_softc *);
 166 static int stg_targ_init(struct stg_softc *, struct targ_info *, int);
 167 static __inline void stghw_bcr_write_1(struct stg_softc *, u_int8_t);
 168 static int stg_timeout(struct stg_softc *);
 169 static void stg_selection_done_and_expect_msgout(struct stg_softc *);
 170
 171 struct scsi_low_funcs stgfuncs = {
 172         SC_LOW_INIT_T stg_world_start,
 173         SC_LOW_BUSRST_T stghw_bus_reset,
 174         SC_LOW_TARG_INIT_T stg_targ_init,
 175         SC_LOW_LUN_INIT_T NULL,
 176
 177         SC_LOW_SELECT_T stghw_start_selection,
 178         SC_LOW_NEXUS_T stg_lun_nexus_establish,
 179         SC_LOW_NEXUS_T stg_ccb_nexus_establish,
 180
 181         SC_LOW_ATTEN_T stghw_attention,
 182         SC_LOW_MSG_T stg_msg,
 183
 184         SC_LOW_TIMEOUT_T stg_timeout,
 185         SC_LOW_POLL_T stgintr,
 186
 187         NULL,
 188 };
 189
 190 /****************************************************
 191  * hwfuncs
 192  ****************************************************/
 193 static __inline void
 194 stghw_bcr_write_1(struct stg_softc *sc, u_int8_t bcv)
 195 {
 196
 197         bus_space_write_1(sc->sc_iot, sc->sc_ioh, tmc_bctl, bcv);
 198         sc->sc_busimg = bcv;
 199 }
 200
 201 static int
 202 stghw_check(sc)
 203         struct stg_softc *sc;
 204 {
 205         struct scsi_low_softc *slp = &sc->sc_sclow;
 206         bus_space_tag_t iot = sc->sc_iot;
 207         bus_space_handle_t ioh = sc->sc_ioh;
 208         u_int fcbsize, fcb;
 209         u_int16_t lsb, msb;
 210
 211         lsb = bus_space_read_1(iot, ioh, tmc_idlsb);
 212         msb = bus_space_read_1(iot, ioh, tmc_idmsb);
 213         switch (msb << 8 | lsb)
 214         {
 215                 case 0x6127:
 216                         /* TMCCHIP_1800 not supported. (it's my policy) */
 217                         sc->sc_chip = TMCCHIP_1800;
 218                         return EINVAL;
 219
 220                 case 0x60e9:
 221                         if (bus_space_read_1(iot, ioh, tmc_cfg2) & 0x02)
 222                         {
 223                                 sc->sc_chip = TMCCHIP_18C30;
 224                                 sc->sc_fsz = TMC18C30_FIFOSZ;
 225                                 fcbsize = TMC18C30_FCBSZ;
 226                         }
 227                         else
 228                         {
 229                                 sc->sc_chip = TMCCHIP_18C50;
 230                                 sc->sc_fsz = TMC18C50_FIFOSZ;
 231                                 fcbsize = TMC18C50_FCBSZ;
 232                         }
 233                         break;
 234
 235                 default:
 236                         sc->sc_chip = TMCCHIP_UNK;
 237                         return ENODEV;
 238         }
 239
 240         sc->sc_fcRinit = FCTL_INTEN;
 241         sc->sc_fcWinit = FCTL_PARENB | FCTL_INTEN;
 242
 243         if (slp->sl_cfgflags & CFG_NOATTEN)
 244                 sc->sc_imsg = 0;
 245         else
 246                 sc->sc_imsg = BCTL_ATN;
 247         sc->sc_busc = BCTL_BUSEN;
 248
 249         sc->sc_wthold = fcbsize + 256;
 250         sc->sc_rthold = fcbsize - 256;
 251         sc->sc_maxwsize = sc->sc_fsz;
 252
 253         fcb = fcbsize / (sc->sc_fsz / 16);
 254         sc->sc_icinit = ICTL_CD | ICTL_SEL | ICTL_ARBIT | fcb;
 255         return 0;
 256 }
 257
 258 static void
 259 stghw_init(sc)
 260         struct stg_softc *sc;
 261 {
 262         bus_space_tag_t iot = sc->sc_iot;
 263         bus_space_handle_t ioh = sc->sc_ioh;
 264
 265         bus_space_write_1(iot, ioh, tmc_ictl, 0);
 266         stghw_bcr_write_1(sc, BCTL_BUSFREE);
 267         bus_space_write_1(iot, ioh, tmc_fctl,
 268                           sc->sc_fcRinit | FCTL_CLRFIFO | FCTL_CLRINT);
 269         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 270         bus_space_write_1(iot, ioh, tmc_ictl, sc->sc_icinit);
 271
 272         bus_space_write_1(iot, ioh, tmc_ssctl, 0);
 273 }
 274
 275 static int
 276 stg_targ_init(sc, ti, action)
 277         struct stg_softc *sc;
 278         struct targ_info *ti;
 279         int action;
 280 {
 281         struct stg_targ_info *sti = (void *) ti;
 282
 283         if (action == SCSI_LOW_INFO_ALLOC || action == SCSI_LOW_INFO_REVOKE)
 284         {
 285                 ti->ti_width = SCSI_LOW_BUS_WIDTH_8;
 286                 ti->ti_maxsynch.period = 0;
 287                 ti->ti_maxsynch.offset = 0;
 288                 sti->sti_reg_synch = 0;
 289         }
 290         return 0;
 291 }
 292
 293 /****************************************************
 294  * scsi low interface
 295  ****************************************************/
 296 static void
 297 stghw_attention(sc)
 298         struct stg_softc *sc;
 299 {
 300
 301         sc->sc_busc |= BCTL_ATN;
 302         sc->sc_busimg |= BCTL_ATN;
 303         bus_space_write_1(sc->sc_iot, sc->sc_ioh, tmc_bctl, sc->sc_busimg);
 304         SCSI_LOW_DELAY(10);
 305 }
 306
 307 static void
 308 stghw_bus_reset(sc)
 309         struct stg_softc *sc;
 310 {
 311         bus_space_tag_t iot = sc->sc_iot;
 312         bus_space_handle_t ioh = sc->sc_ioh;
 313
 314         bus_space_write_1(iot, ioh, tmc_ictl, 0);
 315         bus_space_write_1(iot, ioh, tmc_fctl, 0);
 316         stghw_bcr_write_1(sc, BCTL_RST);
 317         SCSI_LOW_DELAY(100000);
 318         stghw_bcr_write_1(sc, BCTL_BUSFREE);
 319 }
 320
 321 static int
 322 stghw_start_selection(sc, cb)
 323         struct stg_softc *sc;
 324         struct slccb *cb;
 325 {
 326         bus_space_tag_t iot = sc->sc_iot;
 327         bus_space_handle_t ioh = sc->sc_ioh;
 328         struct targ_info *ti = cb->ti;
 329         register u_int8_t stat;
 330         int s;
 331
 332         sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000;
 333         sc->sc_dataout_timeout = 0;
 334         sc->sc_ubf_timeout = 0;
 335         stghw_bcr_write_1(sc, BCTL_BUSFREE);
 336         bus_space_write_1(iot, ioh, tmc_ictl, sc->sc_icinit);
 337
 338         s = splhigh();
 339         stat = bus_space_read_1(iot, ioh, tmc_astat);
 340         if ((stat & ASTAT_INT) != 0)
 341         {
 342                 splx(s);
 343                 return SCSI_LOW_START_FAIL;
 344         }
 345
 346         bus_space_write_1(iot, ioh, tmc_scsiid, sc->sc_idbit);
 347         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit | FCTL_ARBIT);
 348         splx(s);
 349
 350         SCSI_LOW_SETUP_PHASE(ti, PH_ARBSTART);
 351         return SCSI_LOW_START_OK;
 352 }
 353
 354 static int
 355 stg_world_start(sc, fdone)
 356         struct stg_softc *sc;
 357         int fdone;
 358 {
 359         struct scsi_low_softc *slp = &sc->sc_sclow;
 360         int error;
 361
 362         if ((slp->sl_cfgflags & CFG_NOPARITY) == 0)
 363                 sc->sc_fcRinit |= FCTL_PARENB;
 364         else
 365                 sc->sc_fcRinit &= ~FCTL_PARENB;
 366
 367         if ((error = stghw_check(sc)) != 0)
 368                 return error;
 369
 370         stghw_init(sc);
 371         scsi_low_bus_reset(slp);
 372         stghw_init(sc);
 373
 374         SOFT_INTR_REQUIRED(slp);
 375         return 0;
 376 }
 377
 378 static int
 379 stg_msg(sc, ti, msg)
 380         struct stg_softc *sc;
 381         struct targ_info *ti;
 382         u_int msg;
 383 {
 384         bus_space_tag_t iot = sc->sc_iot;
 385         bus_space_handle_t ioh = sc->sc_ioh;
 386         struct stg_targ_info *sti = (void *) ti;
 387         u_int period, offset;
 388
 389         if ((msg & SCSI_LOW_MSG_WIDE) != 0)
 390         {
 391                 if (ti->ti_width != SCSI_LOW_BUS_WIDTH_8)
 392                 {
 393                         ti->ti_width = SCSI_LOW_BUS_WIDTH_8;
 394                         return EINVAL;
 395                 }
 396                 return 0;
 397         }
 398
 399         if ((msg & SCSI_LOW_MSG_SYNCH) == 0)
 400                 return 0;
 401
 402         period = ti->ti_maxsynch.period;
 403         offset = ti->ti_maxsynch.offset;
 404         period = period << 2;
 405         if (period >= 200)
 406         {
 407                 sti->sti_reg_synch = (period - 200) / 50;
 408                 if (period % 50)
 409                         sti->sti_reg_synch ++;
 410                 sti->sti_reg_synch |= SSCTL_SYNCHEN;
 411         }
 412         else if (period >= 100)
 413         {
 414                 sti->sti_reg_synch = (period - 100) / 50;
 415                 if (period % 50)
 416                         sti->sti_reg_synch ++;
 417                 sti->sti_reg_synch |= SSCTL_SYNCHEN | SSCTL_FSYNCHEN;
 418         }
 419         bus_space_write_1(iot, ioh, tmc_ssctl, sti->sti_reg_synch);
 420         return 0;
 421 }
 422
 423 /**************************************************************
 424  * General probe attach
 425  **************************************************************/
 426 int
 427 stgprobesubr(iot, ioh, dvcfg)
 428         bus_space_tag_t iot;
 429         bus_space_handle_t ioh;
 430         u_int dvcfg;
 431 {
 432         u_int16_t lsb, msb;
 433
 434         lsb = bus_space_read_1(iot, ioh, tmc_idlsb);
 435         msb = bus_space_read_1(iot, ioh, tmc_idmsb);
 436         switch (msb << 8 | lsb)
 437         {
 438                 default:
 439                         return 0;
 440                 case 0x6127:
 441                         /* not support! */
 442                         return 0;
 443                 case 0x60e9:
 444                         return 1;
 445         }
 446         return 0;
 447 }
 448
 449 int
 450 stgprint(aux, name)
 451         void *aux;
 452         const char *name;
 453 {
 454
 455         if (name != NULL)
 456                 printf("%s: scsibus ", name);
 457         return UNCONF;
 458 }
 459
 460 void
 461 stgattachsubr(sc)
 462         struct stg_softc *sc;
 463 {
 464         struct scsi_low_softc *slp = &sc->sc_sclow;
 465
 466         printf("\n");
 467
 468         sc->sc_idbit = (1 << slp->sl_hostid);
 469         slp->sl_funcs = &stgfuncs;
 470         sc->sc_tmaxcnt = SCSI_LOW_MIN_TOUT * 1000 * 1000; /* default */
 471
 472         slp->sl_flags |= HW_READ_PADDING;
 473         slp->sl_cfgflags |= CFG_ASYNC;  /* XXX */
 474
 475         (void) scsi_low_attach(slp, 0, STG_NTARGETS, STG_NLUNS,
 476                                 sizeof(struct stg_targ_info), 0);
 477 }
 478
 479 /**************************************************************
 480  * PDMA functions
 481  **************************************************************/
 482 static __inline void
 483 stg_pdma_end(sc, ti)
 484         struct stg_softc *sc;
 485         struct targ_info *ti;
 486 {
 487         struct scsi_low_softc *slp = &sc->sc_sclow;
 488         bus_space_tag_t iot = sc->sc_iot;
 489         bus_space_handle_t ioh = sc->sc_ioh;
 490         struct slccb *cb = slp->sl_Qnexus;
 491         u_int len, tres;
 492
 493         slp->sl_flags &= ~HW_PDMASTART;
 494         sc->sc_icinit &= ~ICTL_FIFO;
 495         sc->sc_dataout_timeout = 0;
 496
 497         if (cb == NULL)
 498         {
 499                 slp->sl_error |= PDMAERR;
 500                 goto out;
 501         }
 502
 503         if (ti->ti_phase == PH_DATA)
 504         {
 505                 len = bus_space_read_2(iot, ioh, tmc_fdcnt);
 506                 if (slp->sl_scp.scp_direction == SCSI_LOW_WRITE)
 507                 {
 508                         if (len != 0)
 509                         {
 510                                 tres = len + slp->sl_scp.scp_datalen;
 511                                 if (tres <= (u_int) cb->ccb_scp.scp_datalen)
 512                                 {
 513                                         slp->sl_scp.scp_data -= len;
 514                                         slp->sl_scp.scp_datalen = tres;
 515                                 }
 516                                 else
 517                                 {
 518                                         slp->sl_error |= PDMAERR;
 519                                         printf("%s len %x >= datalen %x\n",
 520                                                 slp->sl_xname,
 521                                                 len, slp->sl_scp.scp_datalen);
 522                                 }
 523                         }
 524                 }
 525                 else if (slp->sl_scp.scp_direction == SCSI_LOW_READ)
 526                 {
 527                         if (len != 0)
 528                         {
 529                                 slp->sl_error |= PDMAERR;
 530                                 printf("%s: len %x left in fifo\n",
 531                                         slp->sl_xname, len);
 532                         }
 533                 }
 534                 scsi_low_data_finish(slp);
 535         }
 536         else
 537         {
 538
 539                 printf("%s data phase miss\n", slp->sl_xname);
 540                 slp->sl_error |= PDMAERR;
 541         }
 542
 543 out:
 544         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 545 }
 546
 547 static void
 548 stg_pio_read(sc, ti, thold)
 549         struct stg_softc *sc;
 550         struct targ_info *ti;
 551         u_int thold;
 552 {
 553         struct scsi_low_softc *slp = &sc->sc_sclow;
 554         bus_space_tag_t iot = sc->sc_iot;
 555         bus_space_handle_t ioh = sc->sc_ioh;
 556         struct sc_p *sp = &slp->sl_scp;
 557         int s, tout;
 558         u_int res;
 559         u_int8_t stat;
 560
 561         if ((slp->sl_flags & HW_PDMASTART) == 0)
 562         {
 563                 bus_space_write_1(iot, ioh, tmc_fctl,
 564                                   sc->sc_fcRinit | FCTL_FIFOEN);
 565                 slp->sl_flags |= HW_PDMASTART;
 566         }
 567
 568         tout = sc->sc_tmaxcnt;
 569         while (tout -- > 0)
 570         {
 571                 if (thold > 0)
 572                 {
 573                         s = splhigh();
 574                         res = bus_space_read_2(iot, ioh, tmc_fdcnt);
 575                         if (res < thold)
 576                         {
 577                                 bus_space_write_1(iot, ioh, tmc_ictl,
 578                                                   sc->sc_icinit);
 579                                 splx(s);
 580                                 break;
 581                         }
 582                         splx(s);
 583                 }
 584                 else
 585                 {
 586                         stat = bus_space_read_1(iot, ioh, tmc_bstat);
 587                         res = bus_space_read_2(iot, ioh, tmc_fdcnt);
 588                         if (res == 0)
 589                         {
 590                                 if ((stat & PHASE_MASK) != DATA_IN_PHASE)
 591                                         break;
 592                                 if (sp->scp_datalen <= 0)
 593                                         break;
 594                                 SCSI_LOW_DELAY(1);
 595                                 continue;
 596                         }
 597                 }
 598
 599                 /* The assumtion res != 0 is valid here */
 600                 if (res > sp->scp_datalen)
 601                 {
 602                         if (res == (u_int) -1)
 603                                 break;
 604
 605                         slp->sl_error |= PDMAERR;
 606                         if ((slp->sl_flags & HW_READ_PADDING) == 0)
 607                         {
 608                                 printf("%s: read padding required\n",
 609                                         slp->sl_xname);
 610                                 break;
 611                         }
 612
 613                         sp->scp_datalen = 0;
 614                         if (res > STG_MAX_DATA_SIZE)
 615                                 res = STG_MAX_DATA_SIZE;
 616                         while (res -- > 0)
 617                         {
 618                                 (void) bus_space_read_1(iot, ioh, tmc_rfifo);
 619                         }
 620                         continue;
 621                 }
 622
 623                 sp->scp_datalen -= res;
 624                 if (res & 1)
 625                 {
 626                         *sp->scp_data = bus_space_read_1(iot, ioh, tmc_rfifo);
 627                         sp->scp_data ++;
 628                         res --;
 629                 }
 630
 631                 bus_space_read_multi_2(iot, ioh, tmc_rfifo,
 632                                        (u_int16_t *) sp->scp_data, res >> 1);
 633                 sp->scp_data += res;
 634         }
 635
 636         if (tout <= 0)
 637                 printf("%s: pio read timeout\n", slp->sl_xname);
 638 }
 639
 640 static void
 641 stg_pio_write(sc, ti, thold)
 642         struct stg_softc *sc;
 643         struct targ_info *ti;
 644         u_int thold;
 645 {
 646         struct scsi_low_softc *slp = &sc->sc_sclow;
 647         bus_space_tag_t iot = sc->sc_iot;
 648         bus_space_handle_t ioh = sc->sc_ioh;
 649         struct sc_p *sp = &slp->sl_scp;
 650         u_int res;
 651         int s, tout;
 652         register u_int8_t stat;
 653
 654         if ((slp->sl_flags & HW_PDMASTART) == 0)
 655         {
 656                 stat = sc->sc_fcWinit | FCTL_FIFOEN | FCTL_FIFOW;
 657                 bus_space_write_1(iot, ioh, tmc_fctl, stat | FCTL_CLRFIFO);
 658                 bus_space_write_1(iot, ioh, tmc_fctl, stat);
 659                 slp->sl_flags |= HW_PDMASTART;
 660         }
 661
 662         tout = sc->sc_tmaxcnt;
 663         while (tout -- > 0)
 664         {
 665                 stat = bus_space_read_1(iot, ioh, tmc_bstat);
 666                 if ((stat & PHASE_MASK) != DATA_OUT_PHASE)
 667                         break;
 668
 669                 if (sp->scp_datalen <= 0)
 670                 {
 671                         if (sc->sc_dataout_timeout == 0)
 672                                 sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ;
 673                         break;
 674                 }
 675
 676                 if (thold > 0)
 677                 {
 678                         s = splhigh();
 679                         res = bus_space_read_2(iot, ioh, tmc_fdcnt);
 680                         if (res > thold)
 681                         {
 682                                 bus_space_write_1(iot, ioh, tmc_ictl,
 683                                                   sc->sc_icinit);
 684                                 splx(s);
 685                                 break;
 686                         }
 687                         splx(s);
 688                 }
 689                 else
 690                 {
 691                         res = bus_space_read_2(iot, ioh, tmc_fdcnt);
 692                         if (res > sc->sc_maxwsize / 2)
 693                         {
 694                                 SCSI_LOW_DELAY(1);
 695                                 continue;
 696                         }
 697                 }
 698
 699                 if (res == (u_int) -1)
 700                         break;
 701                 res = sc->sc_maxwsize - res;
 702                 if (res > sp->scp_datalen)
 703                         res = sp->scp_datalen;
 704
 705                 sp->scp_datalen -= res;
 706                 if ((res & 0x1) != 0)
 707                 {
 708                         bus_space_write_1(iot, ioh, tmc_wfifo, *sp->scp_data);
 709                         sp->scp_data ++;
 710                         res --;
 711                 }
 712
 713                 bus_space_write_multi_2(iot, ioh, tmc_wfifo,
 714                                         (u_int16_t *) sp->scp_data, res >> 1);
 715                 sp->scp_data += res;
 716         }
 717
 718         if (tout <= 0)
 719                 printf("%s: pio write timeout\n", slp->sl_xname);
 720 }
 721
 722 static int
 723 stg_negate_signal(struct stg_softc *sc, u_int8_t mask, u_char *s)
 724 {
 725         struct scsi_low_softc *slp = &sc->sc_sclow;
 726         bus_space_tag_t bst = sc->sc_iot;
 727         bus_space_handle_t bsh = sc->sc_ioh;
 728         int wc;
 729         u_int8_t regv;
 730
 731         for (wc = 0; wc < STG_DELAY_MAX / STG_DELAY_INTERVAL; wc ++)
 732         {
 733                 regv = bus_space_read_1(bst, bsh, tmc_bstat);
 734                 if (regv == (u_int8_t) -1)
 735                         return -1;
 736                 if ((regv & mask) == 0)
 737                         return 1;
 738
 739                 SCSI_LOW_DELAY(STG_DELAY_INTERVAL);
 740         }
 741
 742         printf("%s: %s stg_negate_signal timeout\n", slp->sl_xname, s);
 743         return -1;
 744 }
 745
 746 static int
 747 stg_expect_signal(struct stg_softc *sc, u_int8_t phase, u_int8_t mask)
 748 {
 749         struct scsi_low_softc *slp = &sc->sc_sclow;
 750         bus_space_tag_t bst = sc->sc_iot;
 751         bus_space_handle_t bsh = sc->sc_ioh;
 752         int wc;
 753         u_int8_t ph;
 754
 755         phase &= PHASE_MASK;
 756         for (wc = 0; wc < STG_DELAY_MAX / STG_DELAY_INTERVAL; wc ++)
 757         {
 758                 ph = bus_space_read_1(bst, bsh, tmc_bstat);
 759                 if (ph == (u_int8_t) -1)
 760                         return -1;
 761                 if ((ph & PHASE_MASK) != phase)
 762                         return 0;
 763                 if ((ph & mask) != 0)
 764                         return 1;
 765
 766                 SCSI_LOW_DELAY(STG_DELAY_INTERVAL);
 767         }
 768
 769         printf("%s: stg_expect_signal timeout\n", slp->sl_xname);
 770         return -1;
 771 }
 772
 773 static int
 774 stg_xfer(sc, buf, len, phase, clear_atn)
 775         struct stg_softc *sc;
 776         u_int8_t *buf;
 777         int len;
 778         int phase;
 779         int clear_atn;
 780 {
 781         bus_space_tag_t iot = sc->sc_iot;
 782         bus_space_handle_t ioh = sc->sc_ioh;
 783         int rv, ptr;
 784
 785         if (phase & BSTAT_IO)
 786                 bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 787         else
 788                 bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcWinit);
 789
 790         for (ptr = 0; len > 0; len --)
 791         {
 792                 rv = stg_expect_signal(sc, phase, BSTAT_REQ);
 793                 if (rv <= 0)
 794                         goto bad;
 795
 796                 if (len == 1 && clear_atn != 0)
 797                 {
 798                         sc->sc_busc &= ~BCTL_ATN;
 799                         stghw_bcr_write_1(sc, sc->sc_busc);
 800                         SCSI_LOW_DEASSERT_ATN(&sc->sc_sclow);
 801                 }
 802
 803                 if (phase & BSTAT_IO)
 804                 {
 805                         buf[ptr ++] = bus_space_read_1(iot, ioh, tmc_rdata);
 806                 }
 807                 else
 808                 {
 809                         bus_space_write_1(iot, ioh, tmc_wdata, buf[ptr ++]);
 810                 }
 811
 812                 stg_negate_signal(sc, BSTAT_ACK, "xfer<ACK>");
 813         }
 814
 815 bad:
 816         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 817         return len;
 818 }
 819
 820 /**************************************************************
 821  * disconnect & reselect (HW low)
 822  **************************************************************/
 823 static int
 824 stg_reselected(sc)
 825         struct stg_softc *sc;
 826 {
 827         struct scsi_low_softc *slp = &sc->sc_sclow;
 828         bus_space_tag_t iot = sc->sc_iot;
 829         bus_space_handle_t ioh = sc->sc_ioh;
 830         int tout;
 831         u_int sid;
 832         u_int8_t regv;
 833
 834         if (slp->sl_selid != NULL)
 835         {
 836                 /* XXX:
 837                  * Selection vs Reselection conflicts.
 838                  */
 839                 bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 840                 stghw_bcr_write_1(sc, BCTL_BUSFREE);
 841         }
 842         else if (slp->sl_Tnexus != NULL)
 843         {
 844                 printf("%s: unexpected termination\n", slp->sl_xname);
 845                 stg_disconnected(sc, slp->sl_Tnexus);
 846         }
 847
 848         /* XXX:
 849          * We should ack the reselection as soon as possible,
 850          * because the target would abort the current reselection seq
 851          * due to reselection timeout.
 852          */
 853         tout = STG_DELAY_SELECT_POLLING_MAX;
 854         while (tout -- > 0)
 855         {
 856                 regv = bus_space_read_1(iot, ioh, tmc_bstat);
 857                 if ((regv & (BSTAT_IO | BSTAT_SEL | BSTAT_BSY)) ==
 858                             (BSTAT_IO | BSTAT_SEL))
 859                 {
 860                         SCSI_LOW_DELAY(1);
 861                         regv = bus_space_read_1(iot, ioh, tmc_bstat);
 862                         if ((regv & (BSTAT_IO | BSTAT_SEL | BSTAT_BSY)) ==
 863                                     (BSTAT_IO | BSTAT_SEL))
 864                                 goto reselect_start;
 865                 }
 866                 SCSI_LOW_DELAY(1);
 867         }
 868         printf("%s: reselction timeout I\n", slp->sl_xname);
 869         return EJUSTRETURN;
 870
 871 reselect_start:
 872         sid = (u_int) bus_space_read_1(iot, ioh, tmc_scsiid);
 873         if ((sid & sc->sc_idbit) == 0)
 874         {
 875                 /* not us */
 876                 return EJUSTRETURN;
 877         }
 878
 879         bus_space_write_1(iot, ioh, tmc_fctl,
 880                             sc->sc_fcRinit | FCTL_CLRFIFO | FCTL_CLRINT);
 881         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 882         stghw_bcr_write_1(sc, sc->sc_busc | BCTL_BSY);
 883
 884         while (tout -- > 0)
 885         {
 886                 regv = bus_space_read_1(iot, ioh, tmc_bstat);
 887                 if ((regv & (BSTAT_SEL | BSTAT_BSY)) == BSTAT_BSY)
 888                         goto reselected;
 889                 SCSI_LOW_DELAY(1);
 890         }
 891         printf("%s: reselction timeout II\n", slp->sl_xname);
 892         return EJUSTRETURN;
 893
 894 reselected:
 895         sid &= ~sc->sc_idbit;
 896         sid = ffs(sid) - 1;
 897         if (scsi_low_reselected(slp, sid) == NULL)
 898                 return EJUSTRETURN;
 899
 900 #ifdef  STG_STATICS
 901         stg_statics.reselect ++;
 902 #endif  /* STG_STATICS */
 903         return EJUSTRETURN;
 904 }
 905
 906 static int
 907 stg_disconnected(sc, ti)
 908         struct stg_softc *sc;
 909         struct targ_info *ti;
 910 {
 911         struct scsi_low_softc *slp = &sc->sc_sclow;
 912         bus_space_tag_t iot = sc->sc_iot;
 913         bus_space_handle_t ioh = sc->sc_ioh;
 914
 915         /* clear bus status & fifo */
 916         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit | FCTL_CLRFIFO);
 917         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
 918         stghw_bcr_write_1(sc, BCTL_BUSFREE);
 919         sc->sc_icinit &= ~ICTL_FIFO;
 920         sc->sc_busc &= ~BCTL_ATN;
 921         sc->sc_dataout_timeout = 0;
 922         sc->sc_ubf_timeout = 0;
 923
 924 #ifdef  STG_STATICS
 925         stg_statics.disconnect ++;
 926 #endif  /* STG_STATICS */
 927         scsi_low_disconnected(slp, ti);
 928         return 1;
 929 }
 930
 931 /**************************************************************
 932  * SEQUENCER
 933  **************************************************************/
 934 static int
 935 stg_target_nexus_establish(sc)
 936         struct stg_softc *sc;
 937 {
 938         struct scsi_low_softc *slp = &sc->sc_sclow;
 939         bus_space_tag_t iot = sc->sc_iot;
 940         bus_space_handle_t ioh = sc->sc_ioh;
 941         struct targ_info *ti = slp->sl_Tnexus;
 942         struct stg_targ_info *sti = (void *) ti;
 943
 944         bus_space_write_1(iot, ioh, tmc_ssctl, sti->sti_reg_synch);
 945         if ((stg_io_control & STG_FIFO_INTERRUPTS) != 0)
 946         {
 947                 sc->sc_icinit |= ICTL_FIFO;
 948         }
 949         return 0;
 950 }
 951
 952 static int
 953 stg_lun_nexus_establish(sc)
 954         struct stg_softc *sc;
 955 {
 956
 957         return 0;
 958 }
 959
 960 static int
 961 stg_ccb_nexus_establish(sc)
 962         struct stg_softc *sc;
 963 {
 964         struct scsi_low_softc *slp = &sc->sc_sclow;
 965         struct slccb *cb = slp->sl_Qnexus;
 966
 967         sc->sc_tmaxcnt = cb->ccb_tcmax * 1000 * 1000;
 968         return 0;
 969 }
 970
 971 #define STGHW_SELECT_INTERVAL   10
 972
 973 static int
 974 stghw_select_targ_wait(sc, mu)
 975         struct stg_softc *sc;
 976         int mu;
 977 {
 978         bus_space_tag_t iot = sc->sc_iot;
 979         bus_space_handle_t ioh = sc->sc_ioh;
 980
 981         mu = mu / STGHW_SELECT_INTERVAL;
 982         while (mu -- > 0)
 983         {
 984                 if ((bus_space_read_1(iot, ioh, tmc_bstat) & BSTAT_BSY) == 0)
 985                 {
 986                         SCSI_LOW_DELAY(STGHW_SELECT_INTERVAL);
 987                         continue;
 988                 }
 989                 SCSI_LOW_DELAY(1);
 990                 if ((bus_space_read_1(iot, ioh, tmc_bstat) & BSTAT_BSY) != 0)
 991                 {
 992                         return 0;
 993                 }
 994         }
 995         return ENXIO;
 996 }
 997
 998 static void
 999 stg_selection_done_and_expect_msgout(sc)
1000         struct stg_softc *sc;
1001 {
1002         struct scsi_low_softc *slp = &sc->sc_sclow;
1003         bus_space_tag_t iot = sc->sc_iot;
1004         bus_space_handle_t ioh = sc->sc_ioh;
1005
1006         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit | FCTL_CLRFIFO);
1007         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
1008         stghw_bcr_write_1(sc, sc->sc_imsg | sc->sc_busc);
1009         SCSI_LOW_ASSERT_ATN(slp);
1010 }
1011
1012 int
1013 stgintr(arg)
1014         void *arg;
1015 {
1016         struct stg_softc *sc = arg;
1017         struct scsi_low_softc *slp = &sc->sc_sclow;
1018         bus_space_tag_t iot = sc->sc_iot;
1019         bus_space_handle_t ioh = sc->sc_ioh;
1020         struct targ_info *ti;
1021         struct physio_proc *pp;
1022         struct buf *bp;
1023         u_int derror, flags;
1024         int len, s;
1025         u_int8_t status, astatus, regv;
1026
1027         /*******************************************
1028          * interrupt check
1029          *******************************************/
1030         if (slp->sl_flags & HW_INACTIVE)
1031                 return 0;
1032
1033         astatus = bus_space_read_1(iot, ioh, tmc_astat);
1034         status = bus_space_read_1(iot, ioh, tmc_bstat);
1035
1036         if ((astatus & ASTAT_STATMASK) == 0 || astatus == (u_int8_t) -1)
1037                 return 0;
1038
1039         bus_space_write_1(iot, ioh, tmc_ictl, 0);
1040         if (astatus & ASTAT_SCSIRST)
1041         {
1042                 bus_space_write_1(iot, ioh, tmc_fctl,
1043                                   sc->sc_fcRinit | FCTL_CLRFIFO);
1044                 bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
1045                 bus_space_write_1(iot, ioh, tmc_ictl, 0);
1046
1047                 scsi_low_restart(slp, SCSI_LOW_RESTART_SOFT,
1048                                  "bus reset (power off?)");
1049                 return 1;
1050         }
1051
1052         /*******************************************
1053          * debug section
1054          *******************************************/
1055 #ifdef  STG_DEBUG
1056         if (stg_debug)
1057         {
1058                 scsi_low_print(slp, NULL);
1059                 printf("%s: st %x ist %x\n\n", slp->sl_xname,
1060                        status, astatus);
1061 #ifdef  KDB
1062                 if (stg_debug > 1)
1063                         SCSI_LOW_DEBUGGER("stg");
1064 #endif  /* KDB */
1065         }
1066 #endif  /* STG_DEBUG */
1067
1068         /*******************************************
1069          * reselection & nexus
1070          *******************************************/
1071         if ((status & RESEL_PHASE_MASK)== PHASE_RESELECTED)
1072         {
1073                 if (stg_reselected(sc) == EJUSTRETURN)
1074                         goto out;
1075         }
1076
1077         if ((ti = slp->sl_Tnexus) == NULL)
1078                 return 0;
1079
1080         derror = 0;
1081         if ((astatus & ASTAT_PARERR) != 0 && ti->ti_phase != PH_ARBSTART &&
1082             (sc->sc_fcRinit & FCTL_PARENB) != 0)
1083         {
1084                 slp->sl_error |= PARITYERR;
1085                 derror = SCSI_LOW_DATA_PE;
1086                 if ((status & PHASE_MASK) == MESSAGE_IN_PHASE)
1087                         scsi_low_assert_msg(slp, ti, SCSI_LOW_MSG_PARITY, 0);
1088                 else
1089                         scsi_low_assert_msg(slp, ti, SCSI_LOW_MSG_ERROR, 1);
1090         }
1091
1092         /*******************************************
1093          * aribitration & selection
1094          *******************************************/
1095         switch (ti->ti_phase)
1096         {
1097         case PH_ARBSTART:
1098                 if ((astatus & ASTAT_ARBIT) == 0)
1099                 {
1100 #ifdef  STG_STATICS
1101                         stg_statics.arbit_fail_0 ++;
1102 #endif  /* STG_STATICS */
1103                         goto arb_fail;
1104                 }
1105
1106                 status = bus_space_read_1(iot, ioh, tmc_bstat);
1107                 if ((status & BSTAT_IO) != 0)
1108                 {
1109                         /* XXX:
1110                          * Selection vs Reselection conflicts.
1111                          */
1112 #ifdef  STG_STATICS
1113                         stg_statics.arbit_fail_1 ++;
1114 #endif  /* STG_STATICS */
1115 arb_fail:
1116                         bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
1117                         stghw_bcr_write_1(sc, BCTL_BUSFREE);
1118                         scsi_low_arbit_fail(slp, slp->sl_Qnexus);
1119                         goto out;
1120                 }
1121
1122                 /*
1123                  * selection assert start.
1124                  */
1125                 SCSI_LOW_SETUP_PHASE(ti, PH_SELSTART);
1126                 scsi_low_arbit_win(slp);
1127
1128                 s = splhigh();
1129                 bus_space_write_1(iot, ioh, tmc_scsiid,
1130                                   sc->sc_idbit | (1 << ti->ti_id));
1131                 stghw_bcr_write_1(sc, sc->sc_imsg | sc->sc_busc | BCTL_SEL);
1132                 bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcWinit);
1133                 if ((stg_io_control & STG_WAIT_FOR_SELECT) != 0)
1134                 {
1135                         /* selection abort delay 200 + 100 micro sec */
1136                         if (stghw_select_targ_wait(sc, 300) == 0)
1137                         {
1138                                 SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED);
1139                                 stg_selection_done_and_expect_msgout(sc);
1140                         }
1141                 }
1142                 splx(s);
1143                 goto out;
1144
1145         case PH_SELSTART:
1146                 if ((status & BSTAT_BSY) == 0)
1147                 {
1148                         /* selection timeout delay 250 ms */
1149                         if (stghw_select_targ_wait(sc, 250 * 1000) != 0)
1150                         {
1151                                 stg_disconnected(sc, ti);
1152                                 goto out;
1153                         }
1154                 }
1155
1156                 SCSI_LOW_SETUP_PHASE(ti, PH_SELECTED);
1157                 stg_selection_done_and_expect_msgout(sc);
1158                 goto out;
1159
1160         case PH_SELECTED:
1161                 if ((status & BSTAT_REQ) == 0)
1162                         goto out;
1163                 stg_target_nexus_establish(sc);
1164                 break;
1165
1166         case PH_RESEL:
1167                 if ((status & BSTAT_REQ) == 0)
1168                         goto out;
1169
1170                 /* clear a busy line */
1171                 bus_space_write_1(iot, ioh, tmc_fctl, sc->sc_fcRinit);
1172                 stghw_bcr_write_1(sc, sc->sc_busc);
1173                 stg_target_nexus_establish(sc);
1174                 if ((status & PHASE_MASK) != MESSAGE_IN_PHASE)
1175                 {
1176                         printf("%s: unexpected phase after reselect\n",
1177                                slp->sl_xname);
1178                         slp->sl_error |= FATALIO;
1179                         scsi_low_assert_msg(slp, ti, SCSI_LOW_MSG_ABORT, 1);
1180                         goto out;
1181                 }
1182                 break;
1183         }
1184
1185         /*******************************************
1186          * data phase
1187          *******************************************/
1188         if ((slp->sl_flags & HW_PDMASTART) && STG_IS_PHASE_DATA(status) == 0)
1189         {
1190                 if (slp->sl_scp.scp_direction == SCSI_LOW_READ)
1191                         stg_pio_read(sc, ti, 0);
1192
1193                 stg_pdma_end(sc, ti);
1194         }
1195
1196         /*******************************************
1197          * scsi seq
1198          *******************************************/
1199         switch (status & PHASE_MASK)
1200         {
1201         case COMMAND_PHASE:
1202                 if (stg_expect_signal(sc, COMMAND_PHASE, BSTAT_REQ) <= 0)
1203                         break;
1204
1205                 SCSI_LOW_SETUP_PHASE(ti, PH_CMD);
1206                 if (scsi_low_cmd(slp, ti) != 0)
1207                 {
1208                         scsi_low_attention(slp);
1209                 }
1210
1211                 if (stg_xfer(sc, slp->sl_scp.scp_cmd, slp->sl_scp.scp_cmdlen,
1212                              COMMAND_PHASE, 0) != 0)
1213                 {
1214                         printf("%s: CMDOUT short\n", slp->sl_xname);
1215                 }
1216                 break;
1217
1218         case DATA_OUT_PHASE:
1219                 SCSI_LOW_SETUP_PHASE(ti, PH_DATA);
1220                 if (scsi_low_data(slp, ti, &bp, SCSI_LOW_WRITE) != 0)
1221                 {
1222                         scsi_low_attention(slp);
1223                 }
1224
1225                 pp = physio_proc_enter(bp);
1226                 if ((sc->sc_icinit & ICTL_FIFO) != 0)
1227                         stg_pio_write(sc, ti, sc->sc_wthold);
1228                 else
1229                         stg_pio_write(sc, ti, 0);
1230                 physio_proc_leave(pp);
1231                 break;
1232
1233         case DATA_IN_PHASE:
1234                 SCSI_LOW_SETUP_PHASE(ti, PH_DATA);
1235                 if (scsi_low_data(slp, ti, &bp, SCSI_LOW_READ) != 0)
1236                 {
1237                         scsi_low_attention(slp);
1238                 }
1239
1240                 pp = physio_proc_enter(bp);
1241                 if ((sc->sc_icinit & ICTL_FIFO) != 0)
1242                         stg_pio_read(sc, ti, sc->sc_rthold);
1243                 else
1244                         stg_pio_read(sc, ti, 0);
1245                 physio_proc_leave(pp);
1246                 break;
1247
1248         case STATUS_PHASE:
1249                 regv = stg_expect_signal(sc, STATUS_PHASE, BSTAT_REQ);
1250                 if (regv <= 0)
1251                         break;
1252
1253                 SCSI_LOW_SETUP_PHASE(ti, PH_STAT);
1254                 regv = bus_space_read_1(iot, ioh, tmc_sdna);
1255                 if (scsi_low_statusin(slp, ti, regv | derror) != 0)
1256                 {
1257                         scsi_low_attention(slp);
1258                 }
1259                 if (regv != bus_space_read_1(iot, ioh, tmc_rdata))
1260                 {
1261                         printf("%s: STATIN: data mismatch\n", slp->sl_xname);
1262                 }
1263                 stg_negate_signal(sc, BSTAT_ACK, "statin<ACK>");
1264                 break;
1265
1266         case MESSAGE_OUT_PHASE:
1267                 if (stg_expect_signal(sc, MESSAGE_OUT_PHASE, BSTAT_REQ) <= 0)
1268                         break;
1269
1270                 SCSI_LOW_SETUP_PHASE(ti, PH_MSGOUT);
1271                 flags = (ti->ti_ophase != ti->ti_phase) ?
1272                                 SCSI_LOW_MSGOUT_INIT : 0;
1273                 len = scsi_low_msgout(slp, ti, flags);
1274
1275                 if (len > 1 && slp->sl_atten == 0)
1276                 {
1277                         scsi_low_attention(slp);
1278                 }
1279
1280                 if (stg_xfer(sc, ti->ti_msgoutstr, len, MESSAGE_OUT_PHASE,
1281                              slp->sl_clear_atten) != 0)
1282                 {
1283                         printf("%s: MSGOUT short\n", slp->sl_xname);
1284                 }
1285                 else
1286                 {
1287                         if (slp->sl_msgphase >= MSGPH_ABORT)
1288                         {
1289                                 stg_disconnected(sc, ti);
1290                         }
1291                 }
1292                 break;
1293
1294         case MESSAGE_IN_PHASE:
1295                 /* confirm phase and req signal */
1296                 if (stg_expect_signal(sc, MESSAGE_IN_PHASE, BSTAT_REQ) <= 0)
1297                         break;
1298
1299                 SCSI_LOW_SETUP_PHASE(ti, PH_MSGIN);
1300
1301                 /* read data with NOACK */
1302                 regv = bus_space_read_1(iot, ioh, tmc_sdna);
1303
1304                 if (scsi_low_msgin(slp, ti, derror | regv) == 0)
1305                 {
1306                         if (scsi_low_is_msgout_continue(ti, 0) != 0)
1307                         {
1308                                 scsi_low_attention(slp);
1309                         }
1310                 }
1311
1312                 /* read data with ACK */
1313                 if (regv != bus_space_read_1(iot, ioh, tmc_rdata))
1314                 {
1315                         printf("%s: MSGIN: data mismatch\n", slp->sl_xname);
1316                 }
1317
1318                 /* wait for the ack negated */
1319                 stg_negate_signal(sc, BSTAT_ACK, "msgin<ACK>");
1320
1321                 if (slp->sl_msgphase != 0 && slp->sl_msgphase < MSGPH_ABORT)
1322                 {
1323                         stg_disconnected(sc, ti);
1324                 }
1325                 break;
1326
1327         case BUSFREE_PHASE:
1328                 printf("%s: unexpected disconnect\n", slp->sl_xname);
1329                 stg_disconnected(sc, ti);
1330                 break;
1331
1332         default:
1333                 slp->sl_error |= FATALIO;
1334                 printf("%s: unknown phase bus %x intr %x\n",
1335                         slp->sl_xname, status, astatus);
1336                 break;
1337         }
1338
1339 out:
1340         bus_space_write_1(iot, ioh, tmc_ictl, sc->sc_icinit);
1341         return 1;
1342 }
1343
1344 static int
1345 stg_timeout(sc)
1346         struct stg_softc *sc;
1347 {
1348         struct scsi_low_softc *slp = &sc->sc_sclow;
1349         bus_space_tag_t iot = sc->sc_iot;
1350         bus_space_handle_t ioh = sc->sc_ioh;
1351         int tout, count;
1352         u_int8_t status;
1353
1354         if (slp->sl_Tnexus == NULL)
1355                 return 0;
1356
1357         status = bus_space_read_1(iot, ioh, tmc_bstat);
1358         if ((status & PHASE_MASK) == 0)
1359         {
1360                 if (sc->sc_ubf_timeout ++ == 0)
1361                         return 0;
1362
1363                 printf("%s: unexpected bus free detected\n", slp->sl_xname);
1364                 slp->sl_error |= FATALIO;
1365                 scsi_low_print(slp, slp->sl_Tnexus);
1366                 stg_disconnected(sc, slp->sl_Tnexus);
1367                 return 0;
1368         }
1369
1370         switch (status & PHASE_MASK)
1371         {
1372         case DATA_OUT_PHASE:
1373                 if (sc->sc_dataout_timeout == 0)
1374                         break;
1375                 if ((status & BSTAT_REQ) == 0)
1376                         break;
1377                 if (bus_space_read_2(iot, ioh, tmc_fdcnt) != 0)
1378                         break;
1379                 if ((-- sc->sc_dataout_timeout) > 0)
1380                         break;
1381
1382                 slp->sl_error |= PDMAERR;
1383                 if ((slp->sl_flags & HW_WRITE_PADDING) == 0)
1384                 {
1385                         printf("%s: write padding required\n",
1386                                 slp->sl_xname);
1387                         break;
1388                 }
1389
1390                 bus_space_write_1(iot, ioh, tmc_ictl, 0);
1391
1392                 tout = STG_DELAY_MAX;
1393                 while (tout --)
1394                 {
1395                         status = bus_space_read_1(iot, ioh, tmc_bstat);
1396                         if ((status & PHASE_MASK) != DATA_OUT_PHASE)
1397                                 break;
1398
1399                         if (bus_space_read_2(iot, ioh, tmc_fdcnt) != 0)
1400                         {
1401                                 SCSI_LOW_DELAY(1);
1402                                 continue;
1403                         }
1404
1405                         for (count = sc->sc_maxwsize; count > 0; count --)
1406                                 bus_space_write_1(iot, ioh, tmc_wfifo, 0);
1407                 }
1408
1409                 status = bus_space_read_1(iot, ioh, tmc_bstat);
1410                 if ((status & PHASE_MASK) == DATA_OUT_PHASE)
1411                         sc->sc_dataout_timeout = SCSI_LOW_TIMEOUT_HZ;
1412
1413                 bus_space_write_1(iot, ioh, tmc_ictl, sc->sc_icinit);
1414                 break;
1415
1416         default:
1417                 break;
1418         }
1419         return 0;
1420 }