sys/dev/disk/vpo/vpoio.c

   1 /*-
   2  * Copyright (c) 1998, 1999 Nicolas Souchu
   3  * Copyright (c) 2000 Alcove - Nicolas Souchu
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD: src/sys/dev/ppbus/vpoio.c,v 1.10.2.3 2001/10/02 05:27:20 nsouch Exp $
  28  */
  29
  30 #ifdef _KERNEL
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/module.h>
  34 #include <sys/bus.h>
  35 #include <sys/malloc.h>
  36
  37 #include <machine/clock.h>
  38
  39 #endif
  40
  41 #ifdef  _KERNEL
  42 #endif
  43
  44 #include "opt_vpo.h"
  45
  46 #include <bus/ppbus/ppbio.h>
  47 #include <bus/ppbus/ppbconf.h>
  48 #include <bus/ppbus/ppb_msq.h>
  49 #include "vpoio.h"
  50
  51 #include "ppbus_if.h"
  52
  53 /*
  54  * The driver pools the drive. We may add a timeout queue to avoid
  55  * active polling on nACK. I've tried this but it leads to unreliable
  56  * transfers
  57  */
  58 #define VP0_SELTMO              5000    /* select timeout */
  59 #define VP0_FAST_SPINTMO        500000  /* wait status timeout */
  60 #define VP0_LOW_SPINTMO         5000000 /* wait status timeout */
  61
  62 /*
  63  * Actually, VP0 timings are more accurate (about few 16MHZ cycles),
  64  * but succeeding in respecting such timings leads to architecture
  65  * dependent considerations.
  66  */
  67 #define VP0_PULSE               1
  68
  69 #define VP0_SECTOR_SIZE 512
  70 #define VP0_BUFFER_SIZE 0x12000
  71
  72 #define n(flags) (~(flags) & (flags))
  73
  74 /*
  75  * VP0 connections.
  76  */
  77 #define H_AUTO          n(AUTOFEED)
  78 #define H_nAUTO         AUTOFEED
  79 #define H_STROBE        n(STROBE)
  80 #define H_nSTROBE       STROBE
  81 #define H_BSY           n(nBUSY)
  82 #define H_nBSY          nBUSY
  83 #define H_SEL           SELECT
  84 #define H_nSEL          n(SELECT)
  85 #define H_ERR           PERROR
  86 #define H_nERR          n(PERROR)
  87 #define H_ACK           nACK
  88 #define H_nACK          n(nACK)
  89 #define H_FLT           nFAULT
  90 #define H_nFLT          n(nFAULT)
  91 #define H_SELIN         n(SELECTIN)
  92 #define H_nSELIN        SELECTIN
  93 #define H_INIT          nINIT
  94 #define H_nINIT         n(nINIT)
  95
  96 /*
  97  * Microcode to execute very fast I/O sequences at the lowest bus level.
  98  */
  99
 100 #define WAIT_RET        MS_PARAM(4, 2, MS_TYP_PTR)
 101 #define WAIT_TMO        MS_PARAM(0, 0, MS_TYP_INT)
 102
 103 #define DECLARE_WAIT_MICROSEQUENCE                      \
 104 struct ppb_microseq wait_microseq[] = {                 \
 105         MS_SET(MS_UNKNOWN),                             \
 106         /* loop */                                      \
 107         MS_BRSET(nBUSY, 2 /* ready */),                 \
 108         MS_DBRA(-2 /* loop */),                         \
 109         MS_RET(1), /* timed out */                      \
 110         /* ready */                                     \
 111         MS_RFETCH(MS_REG_STR, 0xf0, MS_UNKNOWN),        \
 112         MS_RET(0) /* no error */                        \
 113 }
 114
 115 /* call this macro to initialize connect/disconnect microsequences */
 116 #define INIT_TRIG_MICROSEQ {                                            \
 117         int i;                                                          \
 118         for (i=1; i <= 7; i+=2) {                                       \
 119                 disconnect_microseq[i].arg[2].c = d_pulse;              \
 120                 connect_epp_microseq[i].arg[2].c =                      \
 121                 connect_spp_microseq[i].arg[2].c = c_pulse;             \
 122         }                                                               \
 123 }
 124
 125 #define trig_d_pulse MS_TRIG(MS_REG_CTR,5,MS_UNKNOWN /* d_pulse */)
 126 static char d_pulse[] = {
 127          H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
 128         H_nAUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE,
 129          H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
 130          H_AUTO |  H_SELIN | H_INIT | H_STROBE, VP0_PULSE,
 131          H_AUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE
 132 };
 133
 134 #define trig_c_pulse MS_TRIG(MS_REG_CTR,5,MS_UNKNOWN /* c_pulse */)
 135 static char c_pulse[] = {
 136          H_AUTO | H_nSELIN | H_INIT | H_STROBE, 0,
 137          H_AUTO |  H_SELIN | H_INIT | H_STROBE, 0,
 138         H_nAUTO |  H_SELIN | H_INIT | H_STROBE, VP0_PULSE,
 139          H_AUTO |  H_SELIN | H_INIT | H_STROBE, 0,
 140          H_AUTO | H_nSELIN | H_INIT | H_STROBE, VP0_PULSE
 141 };
 142
 143 static struct ppb_microseq disconnect_microseq[] = {
 144           MS_DASS(0x0), trig_d_pulse, MS_DASS(0x3c), trig_d_pulse,
 145           MS_DASS(0x20), trig_d_pulse, MS_DASS(0xf), trig_d_pulse, MS_RET(0)
 146 };
 147
 148 static struct ppb_microseq connect_epp_microseq[] = {
 149           MS_DASS(0x0), trig_c_pulse, MS_DASS(0x3c), trig_c_pulse,
 150           MS_DASS(0x20), trig_c_pulse, MS_DASS(0xcf), trig_c_pulse, MS_RET(0)
 151 };
 152
 153 static struct ppb_microseq connect_spp_microseq[] = {
 154           MS_DASS(0x0), trig_c_pulse, MS_DASS(0x3c), trig_c_pulse,
 155           MS_DASS(0x20), trig_c_pulse, MS_DASS(0x8f), trig_c_pulse, MS_RET(0)
 156 };
 157
 158 /*
 159  * nibble_inbyte_hook()
 160  *
 161  * Formats high and low nibble into a character
 162  */
 163 static int
 164 nibble_inbyte_hook (void *p, char *ptr)
 165 {
 166         struct vpo_nibble *s = (struct vpo_nibble *)p;
 167
 168         /* increment the buffer pointer */
 169         *ptr++ = ((s->l >> 4) & 0x0f) + (s->h & 0xf0);
 170
 171         return (0);
 172 }
 173
 174 #define INB_NIBBLE_H MS_PARAM(2, 2, MS_TYP_PTR)
 175 #define INB_NIBBLE_L MS_PARAM(4, 2, MS_TYP_PTR)
 176 #define INB_NIBBLE_F MS_PARAM(5, 0, MS_TYP_FUN)
 177 #define INB_NIBBLE_P MS_PARAM(5, 1, MS_TYP_PTR)
 178
 179 /*
 180  * This is the sub-microseqence for MS_GET in NIBBLE mode
 181  * Retrieve the two nibbles and call the C function to generate the character
 182  * and store it in the buffer (see nibble_inbyte_hook())
 183  */
 184
 185 #define DECLARE_NIBBLE_INBYTE_SUBMICROSEQ                       \
 186 struct ppb_microseq nibble_inbyte_submicroseq[] = {             \
 187 /* loop: */                                                     \
 188           MS_CASS( H_AUTO | H_SELIN | H_INIT | H_STROBE),       \
 189           MS_DELAY(VP0_PULSE),                                  \
 190           MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* high nibble */),\
 191           MS_CASS(H_nAUTO | H_SELIN | H_INIT | H_STROBE),       \
 192           MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* low nibble */),\
 193           /* do a C call to format the received nibbles */      \
 194           MS_C_CALL(MS_UNKNOWN /* C hook */, MS_UNKNOWN /* param */),\
 195           MS_DBRA(-7 /* loop */),                               \
 196           MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),       \
 197           MS_RET(0)                                             \
 198 }
 199
 200 /*
 201  * This is the sub-microseqence for MS_GET in PS2 mode
 202  */
 203 static struct ppb_microseq ps2_inbyte_submicroseq[] = {
 204           MS_CASS(PCD | H_AUTO | H_SELIN | H_INIT | H_nSTROBE),
 205
 206 /* loop: */
 207           MS_RFETCH_P(1, MS_REG_DTR, MS_FETCH_ALL),
 208           MS_CASS(PCD | H_nAUTO | H_SELIN | H_INIT | H_nSTROBE),
 209           MS_CASS(PCD |  H_AUTO | H_SELIN | H_INIT | H_nSTROBE),
 210           MS_DBRA(-4 /* loop */),
 211
 212           MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
 213           MS_RET(0)
 214 };
 215
 216 /*
 217  * This is the sub-microsequence for MS_PUT in both NIBBLE and PS2 modes
 218  */
 219 static struct ppb_microseq spp_outbyte_submicroseq[] = {
 220
 221 /* loop: */
 222           MS_RASSERT_P(1, MS_REG_DTR),
 223           MS_CASS(H_nAUTO | H_nSELIN | H_INIT | H_STROBE),
 224           MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
 225           MS_DELAY(VP0_PULSE),
 226           MS_DBRA(-5 /* loop */),
 227
 228           /* return from the put call */
 229           MS_RET(0)
 230 };
 231
 232 /* EPP 1.7 microsequences, ptr and len set at runtime */
 233 static struct ppb_microseq epp17_outstr_body[] = {
 234           MS_CASS(H_AUTO | H_SELIN | H_INIT | H_STROBE),
 235
 236 /* loop: */
 237           MS_RASSERT_P(1, MS_REG_EPP_D),
 238           MS_BRSET(TIMEOUT, 3 /* error */),     /* EPP timeout? */
 239           MS_DBRA(-3 /* loop */),
 240
 241           MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
 242           MS_RET(0),
 243 /* error: */
 244           MS_CASS(H_AUTO | H_nSELIN | H_INIT | H_STROBE),
 245           MS_RET(1)
 246 };
 247
 248 static struct ppb_microseq epp17_instr_body[] = {
 249           MS_CASS(PCD | H_AUTO | H_SELIN | H_INIT | H_STROBE),
 250
 251 /* loop: */
 252           MS_RFETCH_P(1, MS_REG_EPP_D, MS_FETCH_ALL),
 253           MS_BRSET(TIMEOUT, 3 /* error */),     /* EPP timeout? */
 254           MS_DBRA(-3 /* loop */),
 255
 256           MS_CASS(PCD | H_AUTO | H_nSELIN | H_INIT | H_STROBE),
 257           MS_RET(0),
 258 /* error: */
 259           MS_CASS(PCD | H_AUTO | H_nSELIN | H_INIT | H_STROBE),
 260           MS_RET(1)
 261 };
 262
 263 static struct ppb_microseq in_disk_mode[] = {
 264           MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
 265           MS_CASS(H_nAUTO | H_nSELIN | H_INIT | H_STROBE),
 266
 267           MS_BRCLEAR(H_FLT, 3 /* error */),
 268           MS_CASS( H_AUTO | H_nSELIN | H_INIT | H_STROBE),
 269           MS_BRSET(H_FLT, 1 /* error */),
 270
 271           MS_RET(1),
 272 /* error: */
 273           MS_RET(0)
 274 };
 275
 276 static int
 277 vpoio_disconnect(struct vpoio_data *vpo)
 278 {
 279         device_t ppbus = device_get_parent(vpo->vpo_dev);
 280         int ret;
 281
 282         ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
 283         return (ppb_release_bus(ppbus, vpo->vpo_dev));
 284 }
 285
 286 /*
 287  * how  : PPB_WAIT or PPB_DONTWAIT
 288  */
 289 static int
 290 vpoio_connect(struct vpoio_data *vpo, int how)
 291 {
 292         device_t ppbus = device_get_parent(vpo->vpo_dev);
 293         int error;
 294         int ret;
 295
 296         if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, how))) {
 297
 298 #ifdef VP0_DEBUG
 299                 kprintf("%s: can't request bus!\n", __func__);
 300 #endif
 301                 return error;
 302         }
 303
 304         if (PPB_IN_EPP_MODE(ppbus))
 305                 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_epp_microseq, &ret);
 306         else
 307                 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_spp_microseq, &ret);
 308
 309         return (0);
 310 }
 311
 312 /*
 313  * vpoio_reset()
 314  *
 315  * SCSI reset signal, the drive must be in disk mode
 316  */
 317 static void
 318 vpoio_reset (struct vpoio_data *vpo)
 319 {
 320         device_t ppbus = device_get_parent(vpo->vpo_dev);
 321         int ret;
 322
 323         struct ppb_microseq reset_microseq[] = {
 324
 325                 #define INITIATOR       MS_PARAM(0, 1, MS_TYP_INT)
 326
 327                 MS_DASS(MS_UNKNOWN),
 328                 MS_CASS(H_AUTO | H_nSELIN | H_nINIT | H_STROBE),
 329                 MS_DELAY(25),
 330                 MS_CASS(H_AUTO | H_nSELIN |  H_INIT | H_STROBE),
 331                 MS_RET(0)
 332         };
 333
 334         ppb_MS_init_msq(reset_microseq, 1, INITIATOR, 1 << VP0_INITIATOR);
 335         ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, &ret);
 336
 337         return;
 338 }
 339
 340 /*
 341  * vpoio_in_disk_mode()
 342  */
 343 static int
 344 vpoio_in_disk_mode(struct vpoio_data *vpo)
 345 {
 346         device_t ppbus = device_get_parent(vpo->vpo_dev);
 347         int ret;
 348
 349         ppb_MS_microseq(ppbus, vpo->vpo_dev, in_disk_mode, &ret);
 350
 351         return (ret);
 352 }
 353
 354 /*
 355  * vpoio_detect()
 356  *
 357  * Detect and initialise the VP0 adapter.
 358  */
 359 static int
 360 vpoio_detect(struct vpoio_data *vpo)
 361 {
 362         device_t ppbus = device_get_parent(vpo->vpo_dev);
 363         int error, ret;
 364
 365         /* allocate the bus, then apply microsequences */
 366         if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_DONTWAIT)))
 367                 return (error);
 368
 369         /* Force disconnection */
 370         ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
 371
 372         /* Try to enter EPP mode, then connect to the drive in EPP mode */
 373         if (ppb_set_mode(ppbus, PPB_EPP) != -1) {
 374                 /* call manually the microseq instead of using the appropriate function
 375                  * since we already requested the ppbus */
 376                 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_epp_microseq, &ret);
 377         }
 378
 379         /* If EPP mode switch failed or ZIP connection in EPP mode failed,
 380          * try to connect in NIBBLE mode */
 381         if (!vpoio_in_disk_mode(vpo)) {
 382
 383                 /* The interface must be at least PS/2 or NIBBLE capable.
 384                  * There is no way to know if the ZIP will work with
 385                  * PS/2 mode since PS/2 and SPP both use the same connect
 386                  * sequence. One must supress PS/2 with boot flags if
 387                  * PS/2 mode fails (see ppc(4)).
 388                  */
 389                 if (ppb_set_mode(ppbus, PPB_PS2) != -1) {
 390                         vpo->vpo_mode_found = VP0_MODE_PS2;
 391                 } else {
 392                         if (ppb_set_mode(ppbus, PPB_NIBBLE) == -1)
 393                                 goto error;
 394
 395                         vpo->vpo_mode_found = VP0_MODE_NIBBLE;
 396                 }
 397
 398                 /* Can't know if the interface is capable of PS/2 yet */
 399                 ppb_MS_microseq(ppbus, vpo->vpo_dev, connect_spp_microseq, &ret);
 400                 if (!vpoio_in_disk_mode(vpo)) {
 401                         vpo->vpo_mode_found = VP0_MODE_UNDEFINED;
 402                         if (bootverbose)
 403                                 kprintf("vpo%d: can't connect to the drive\n",
 404                                         vpo->vpo_unit);
 405
 406                         /* disconnect and release the bus */
 407                         ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq,
 408                                         &ret);
 409                         goto error;
 410                 }
 411         } else {
 412                 vpo->vpo_mode_found = VP0_MODE_EPP;
 413         }
 414
 415         /* send SCSI reset signal */
 416         vpoio_reset(vpo);
 417
 418         ppb_MS_microseq(ppbus, vpo->vpo_dev, disconnect_microseq, &ret);
 419
 420         /* ensure we are disconnected or daisy chained peripheral
 421          * may cause serious problem to the disk */
 422         if (vpoio_in_disk_mode(vpo)) {
 423                 if (bootverbose)
 424                         kprintf("vpo%d: can't disconnect from the drive\n",
 425                                 vpo->vpo_unit);
 426                 goto error;
 427         }
 428
 429         ppb_release_bus(ppbus, vpo->vpo_dev);
 430         return (0);
 431
 432 error:
 433         ppb_release_bus(ppbus, vpo->vpo_dev);
 434         return (VP0_EINITFAILED);
 435 }
 436
 437 /*
 438  * vpoio_outstr()
 439  */
 440 static int
 441 vpoio_outstr(struct vpoio_data *vpo, char *_buffer, int _size)
 442 {
 443         union ppb_insarg buffer = { .c = _buffer };
 444         union ppb_insarg size = { .i = _size };
 445         union ppb_insarg unknown = { .i = MS_UNKNOWN };
 446         device_t ppbus = device_get_parent(vpo->vpo_dev);
 447         int error = 0;
 448
 449         ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_PUT, buffer, size, unknown,
 450             &error);
 451
 452         ppb_ecp_sync(ppbus);
 453
 454         return (error);
 455 }
 456
 457 /*
 458  * vpoio_instr()
 459  */
 460 static int
 461 vpoio_instr(struct vpoio_data *vpo, char *_buffer, int _size)
 462 {
 463         union ppb_insarg buffer = { .c = _buffer };
 464         union ppb_insarg size = { .i = _size };
 465         union ppb_insarg unknown = { .i = MS_UNKNOWN };
 466         device_t ppbus = device_get_parent(vpo->vpo_dev);
 467         int error = 0;
 468
 469         ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_GET, buffer, size, unknown,
 470             &error);
 471
 472         ppb_ecp_sync(ppbus);
 473
 474         return (error);
 475 }
 476
 477 static char
 478 vpoio_select(struct vpoio_data *vpo, int initiator, int target)
 479 {
 480         device_t ppbus = device_get_parent(vpo->vpo_dev);
 481         int ret;
 482
 483         struct ppb_microseq select_microseq[] = {
 484
 485                 /* parameter list
 486                  */
 487                 #define SELECT_TARGET           MS_PARAM(0, 1, MS_TYP_INT)
 488                 #define SELECT_INITIATOR        MS_PARAM(3, 1, MS_TYP_INT)
 489
 490                 /* send the select command to the drive */
 491                 MS_DASS(MS_UNKNOWN),
 492                 MS_CASS(H_nAUTO | H_nSELIN |  H_INIT | H_STROBE),
 493                 MS_CASS( H_AUTO | H_nSELIN |  H_INIT | H_STROBE),
 494                 MS_DASS(MS_UNKNOWN),
 495                 MS_CASS( H_AUTO | H_nSELIN | H_nINIT | H_STROBE),
 496
 497                 /* now, wait until the drive is ready */
 498                 MS_SET(VP0_SELTMO),
 499 /* loop: */     MS_BRSET(H_ACK, 2 /* ready */),
 500                 MS_DBRA(-2 /* loop */),
 501 /* error: */    MS_RET(1),
 502 /* ready: */    MS_RET(0)
 503         };
 504
 505         /* initialize the select microsequence */
 506         ppb_MS_init_msq(select_microseq, 2,
 507                         SELECT_TARGET, 1 << target,
 508                         SELECT_INITIATOR, 1 << initiator);
 509
 510         ppb_MS_microseq(ppbus, vpo->vpo_dev, select_microseq, &ret);
 511
 512         if (ret)
 513                 return (VP0_ESELECT_TIMEOUT);
 514
 515         return (0);
 516 }
 517
 518 /*
 519  * vpoio_wait()
 520  *
 521  * H_SELIN must be low.
 522  *
 523  * XXX should be ported to microseq
 524  */
 525 static char
 526 vpoio_wait(struct vpoio_data *vpo, int tmo)
 527 {
 528         DECLARE_WAIT_MICROSEQUENCE;
 529
 530         device_t ppbus = device_get_parent(vpo->vpo_dev);
 531         int ret, err;
 532
 533 #if 0   /* broken */
 534         if (ppb_poll_device(ppbus, 150, nBUSY, nBUSY, PPB_INTR))
 535                 return (0);
 536
 537         return (ppb_rstr(ppbus) & 0xf0);
 538 #endif
 539
 540         /*
 541          * Return some status information.
 542          * Semantics :  0xc0 = ZIP wants more data
 543          *              0xd0 = ZIP wants to send more data
 544          *              0xe0 = ZIP wants command
 545          *              0xf0 = end of transfer, ZIP is sending status
 546          */
 547
 548         ppb_MS_init_msq(wait_microseq, 2,
 549                         WAIT_RET, (void *)&ret,
 550                         WAIT_TMO, tmo);
 551
 552         ppb_MS_microseq(ppbus, vpo->vpo_dev, wait_microseq, &err);
 553
 554         if (err)
 555                 return (0);      /* command timed out */
 556
 557         return(ret);
 558 }
 559
 560 /*
 561  * vpoio_probe()
 562  *
 563  * Low level probe of vpo device
 564  *
 565  */
 566 int
 567 vpoio_probe(device_t dev, struct vpoio_data *vpo)
 568 {
 569         int error;
 570
 571         /* ppbus dependent initialisation */
 572         vpo->vpo_dev = dev;
 573
 574         /*
 575          * Initialize microsequence code
 576          */
 577         INIT_TRIG_MICROSEQ;
 578
 579         /* now, try to initialise the drive */
 580         if ((error = vpoio_detect(vpo))) {
 581                 return (error);
 582         }
 583
 584         return (0);
 585 }
 586
 587 /*
 588  * vpoio_attach()
 589  *
 590  * Low level attachment of vpo device
 591  *
 592  */
 593 int
 594 vpoio_attach(struct vpoio_data *vpo)
 595 {
 596         DECLARE_NIBBLE_INBYTE_SUBMICROSEQ;
 597         device_t ppbus = device_get_parent(vpo->vpo_dev);
 598         int error = 0;
 599
 600         vpo->vpo_nibble_inbyte_msq = kmalloc(sizeof(nibble_inbyte_submicroseq),
 601                                                 M_DEVBUF, M_WAITOK);
 602
 603         bcopy((void *)nibble_inbyte_submicroseq,
 604                 (void *)vpo->vpo_nibble_inbyte_msq,
 605                 sizeof(nibble_inbyte_submicroseq));
 606
 607         ppb_MS_init_msq(vpo->vpo_nibble_inbyte_msq, 4,
 608                 INB_NIBBLE_H, (void *)&(vpo)->vpo_nibble.h,
 609                 INB_NIBBLE_L, (void *)&(vpo)->vpo_nibble.l,
 610                 INB_NIBBLE_F, nibble_inbyte_hook,
 611                 INB_NIBBLE_P, (void *)&(vpo)->vpo_nibble);
 612
 613         /*
 614          * Initialize mode dependent in/out microsequences
 615          */
 616         if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_WAIT)))
 617                 goto error;
 618
 619         /* ppbus sets automatically the last mode entered during detection */
 620         switch (vpo->vpo_mode_found) {
 621         case VP0_MODE_EPP:
 622                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, epp17_instr_body);
 623                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, epp17_outstr_body);
 624                 kprintf("vpo%d: EPP mode\n", vpo->vpo_unit);
 625                 break;
 626         case VP0_MODE_PS2:
 627                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, ps2_inbyte_submicroseq);
 628                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
 629                 kprintf("vpo%d: PS2 mode\n", vpo->vpo_unit);
 630                 break;
 631         case VP0_MODE_NIBBLE:
 632                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, vpo->vpo_nibble_inbyte_msq);
 633                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
 634                 kprintf("vpo%d: NIBBLE mode\n", vpo->vpo_unit);
 635                 break;
 636         default:
 637                 panic("vpo: unknown mode %d", vpo->vpo_mode_found);
 638         }
 639
 640         ppb_release_bus(ppbus, vpo->vpo_dev);
 641
 642 error:
 643         return (error);
 644 }
 645
 646 /*
 647  * vpoio_reset_bus()
 648  *
 649  */
 650 int
 651 vpoio_reset_bus(struct vpoio_data *vpo)
 652 {
 653         /* first, connect to the drive */
 654         if (vpoio_connect(vpo, PPB_WAIT|PPB_INTR) || !vpoio_in_disk_mode(vpo)) {
 655
 656 #ifdef VP0_DEBUG
 657                 kprintf("%s: not in disk mode!\n", __func__);
 658 #endif
 659                 /* release ppbus */
 660                 vpoio_disconnect(vpo);
 661                 return (1);
 662         }
 663
 664         /* reset the SCSI bus */
 665         vpoio_reset(vpo);
 666
 667         /* then disconnect */
 668         vpoio_disconnect(vpo);
 669
 670         return (0);
 671 }
 672
 673 /*
 674  * vpoio_do_scsi()
 675  *
 676  * Send an SCSI command
 677  *
 678  */
 679 int
 680 vpoio_do_scsi(struct vpoio_data *vpo, int host, int target, char *command,
 681                 int clen, char *buffer, int blen, int *result, int *count,
 682                 int *ret)
 683 {
 684         device_t ppbus = device_get_parent(vpo->vpo_dev);
 685         char r;
 686         char l, h = 0;
 687         int len, error = 0;
 688         int k;
 689
 690         /*
 691          * enter disk state, allocate the ppbus
 692          *
 693          * XXX
 694          * Should we allow this call to be interruptible?
 695          * The only way to report the interruption is to return
 696          * EIO do upper SCSI code :^(
 697          */
 698         if ((error = vpoio_connect(vpo, PPB_WAIT|PPB_INTR)))
 699                 return (error);
 700
 701         if (!vpoio_in_disk_mode(vpo)) {
 702                 *ret = VP0_ECONNECT; goto error;
 703         }
 704
 705         if ((*ret = vpoio_select(vpo,host,target)))
 706                 goto error;
 707
 708         /*
 709          * Send the command ...
 710          *
 711          * set H_SELIN low for vpoio_wait().
 712          */
 713         ppb_wctr(ppbus, H_AUTO | H_nSELIN | H_INIT | H_STROBE);
 714
 715         for (k = 0; k < clen; k++) {
 716                 if (vpoio_wait(vpo, VP0_FAST_SPINTMO) != (char)0xe0) {
 717                         *ret = VP0_ECMD_TIMEOUT;
 718                         goto error;
 719                 }
 720                 if (vpoio_outstr(vpo, &command[k], 1)) {
 721                         *ret = VP0_EPPDATA_TIMEOUT;
 722                         goto error;
 723                 }
 724         }
 725
 726         /*
 727          * Completion ...
 728          */
 729
 730         *count = 0;
 731         for (;;) {
 732
 733                 if (!(r = vpoio_wait(vpo, VP0_LOW_SPINTMO))) {
 734                         *ret = VP0_ESTATUS_TIMEOUT; goto error;
 735                 }
 736
 737                 /* stop when the ZIP wants to send status */
 738                 if (r == (char)0xf0)
 739                         break;
 740
 741                 if (*count >= blen) {
 742                         *ret = VP0_EDATA_OVERFLOW;
 743                         goto error;
 744                 }
 745
 746                 /* if in EPP mode or writing bytes, try to transfer a sector
 747                  * otherwise, just send one byte
 748                  */
 749                 if (PPB_IN_EPP_MODE(ppbus) || r == (char)0xc0)
 750                         len = (((blen - *count) >= VP0_SECTOR_SIZE)) ?
 751                                 VP0_SECTOR_SIZE : 1;
 752                 else
 753                         len = 1;
 754
 755                 /* ZIP wants to send data? */
 756                 if (r == (char)0xc0)
 757                         error = vpoio_outstr(vpo, &buffer[*count], len);
 758                 else
 759                         error = vpoio_instr(vpo, &buffer[*count], len);
 760
 761                 if (error) {
 762                         *ret = error;
 763                         goto error;
 764                 }
 765
 766                 *count += len;
 767         }
 768
 769         if (vpoio_instr(vpo, &l, 1)) {
 770                 *ret = VP0_EOTHER; goto error;
 771         }
 772
 773         /* check if the ZIP wants to send more status */
 774         if (vpoio_wait(vpo, VP0_FAST_SPINTMO) == (char)0xf0)
 775                 if (vpoio_instr(vpo, &h, 1)) {
 776                         *ret = VP0_EOTHER+2; goto error;
 777                 }
 778
 779         *result = ((int) h << 8) | ((int) l & 0xff);
 780
 781 error:
 782         /* return to printer state, release the ppbus */
 783         vpoio_disconnect(vpo);
 784         return (0);
 785 }