sys/dev/ppbus/immio.c

   1 /*-
   2  * Copyright (c) 1998, 1999 Nicolas Souchu
   3  * Copyright (c) 2001 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  *
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 /*
  34  * Iomega ZIP+ Matchmaker Parallel Port Interface driver
  35  *
  36  * Thanks to David Campbell work on the Linux driver and the Iomega specs
  37  * Thanks to Thiebault Moeglin for the drive
  38  */
  39 #ifdef _KERNEL
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/module.h>
  43 #include <sys/bus.h>
  44 #include <sys/malloc.h>
  45
  46 #endif  /* _KERNEL */
  47
  48 #include "opt_vpo.h"
  49
  50 #include <dev/ppbus/ppbio.h>
  51 #include <dev/ppbus/ppbconf.h>
  52 #include <dev/ppbus/ppb_msq.h>
  53 #include <dev/ppbus/vpoio.h>
  54 #include <dev/ppbus/ppb_1284.h>
  55
  56 #include "ppbus_if.h"
  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 #define VP0_SECTOR_SIZE 512
  63
  64 /*
  65  * Microcode to execute very fast I/O sequences at the lowest bus level.
  66  */
  67
  68 #define WAIT_RET                MS_PARAM(7, 2, MS_TYP_PTR)
  69 #define WAIT_TMO                MS_PARAM(1, 0, MS_TYP_INT)
  70
  71 #define DECLARE_WAIT_MICROSEQUENCE \
  72 struct ppb_microseq wait_microseq[] = {                                 \
  73         MS_CASS(0x0c),                                                  \
  74         MS_SET(MS_UNKNOWN),                                             \
  75         /* loop */                                                      \
  76         MS_BRSET(nBUSY, 4 /* ready */),                                 \
  77         MS_DBRA(-2 /* loop */),                                         \
  78         MS_CASS(0x04),                                                  \
  79         MS_RET(1), /* timed out */                                      \
  80         /* ready */                                                     \
  81         MS_CASS(0x04),                                                  \
  82         MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN ),                       \
  83         MS_RET(0) /* no error */                                        \
  84 }
  85
  86 #define SELECT_TARGET           MS_PARAM(6, 1, MS_TYP_CHA)
  87
  88 #define DECLARE_SELECT_MICROSEQUENCE \
  89 struct ppb_microseq select_microseq[] = {                               \
  90         MS_CASS(0xc),                                                   \
  91         /* first, check there is nothing holding onto the bus */        \
  92         MS_SET(VP0_SELTMO),                                             \
  93 /* _loop: */                                                            \
  94         MS_BRCLEAR(0x8, 2 /* _ready */),                                \
  95         MS_DBRA(-2 /* _loop */),                                        \
  96         MS_RET(2),                      /* bus busy */                  \
  97 /* _ready: */                                                           \
  98         MS_CASS(0x4),                                                   \
  99         MS_DASS(MS_UNKNOWN /* 0x80 | 1 << target */),                   \
 100         MS_DELAY(1),                                                    \
 101         MS_CASS(0xc),                                                   \
 102         MS_CASS(0xd),                                                   \
 103         /* now, wait until the drive is ready */                        \
 104         MS_SET(VP0_SELTMO),                                             \
 105 /* loop: */                                                             \
 106         MS_BRSET(0x8, 3 /* ready */),                                   \
 107         MS_DBRA(-2 /* loop */),                                         \
 108 /* error: */                                                            \
 109         MS_CASS(0xc),                                                   \
 110         MS_RET(VP0_ESELECT_TIMEOUT),                                    \
 111 /* ready: */                                                            \
 112         MS_CASS(0xc),                                                   \
 113         MS_RET(0)                                                       \
 114 }
 115
 116 static struct ppb_microseq transfer_epilog[] = {
 117         MS_CASS(0x4),
 118         MS_CASS(0xc),
 119         MS_CASS(0xe),
 120         MS_CASS(0x4),
 121         MS_RET(0)
 122 };
 123
 124 #define CPP_S1          MS_PARAM(10, 2, MS_TYP_PTR)
 125 #define CPP_S2          MS_PARAM(13, 2, MS_TYP_PTR)
 126 #define CPP_S3          MS_PARAM(16, 2, MS_TYP_PTR)
 127 #define CPP_PARAM       MS_PARAM(17, 1, MS_TYP_CHA)
 128
 129 #define DECLARE_CPP_MICROSEQ \
 130 struct ppb_microseq cpp_microseq[] = {                                  \
 131         MS_CASS(0x0c), MS_DELAY(2),                                     \
 132         MS_DASS(0xaa), MS_DELAY(10),                                    \
 133         MS_DASS(0x55), MS_DELAY(10),                                    \
 134         MS_DASS(0x00), MS_DELAY(10),                                    \
 135         MS_DASS(0xff), MS_DELAY(10),                                    \
 136         MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN /* &s1 */),              \
 137         MS_DASS(0x87), MS_DELAY(10),                                    \
 138         MS_RFETCH(MS_REG_STR, 0xb8, MS_UNKNOWN /* &s2 */),              \
 139         MS_DASS(0x78), MS_DELAY(10),                                    \
 140         MS_RFETCH(MS_REG_STR, 0x38, MS_UNKNOWN /* &s3 */),              \
 141         MS_DASS(MS_UNKNOWN /* param */),                                \
 142         MS_DELAY(2),                                                    \
 143         MS_CASS(0x0c), MS_DELAY(10),                                    \
 144         MS_CASS(0x0d), MS_DELAY(2),                                     \
 145         MS_CASS(0x0c), MS_DELAY(10),                                    \
 146         MS_DASS(0xff), MS_DELAY(10),                                    \
 147         MS_RET(0)                                                       \
 148 }
 149
 150 #define NEGOCIATED_MODE         MS_PARAM(2, 1, MS_TYP_CHA)
 151
 152 #define DECLARE_NEGOCIATE_MICROSEQ \
 153 struct ppb_microseq negociate_microseq[] = {                            \
 154         MS_CASS(0x4),                                                   \
 155         MS_DELAY(5),                                                    \
 156         MS_DASS(MS_UNKNOWN /* mode */),                                 \
 157         MS_DELAY(100),                                                  \
 158         MS_CASS(0x6),                                                   \
 159         MS_DELAY(5),                                                    \
 160         MS_BRSET(0x20, 5 /* continue */),                               \
 161         MS_DELAY(5),                                                    \
 162         MS_CASS(0x7),                                                   \
 163         MS_DELAY(5),                                                    \
 164         MS_CASS(0x6),                                                   \
 165         MS_RET(VP0_ENEGOCIATE),                                         \
 166 /* continue: */                                                         \
 167         MS_DELAY(5),                                                    \
 168         MS_CASS(0x7),                                                   \
 169         MS_DELAY(5),                                                    \
 170         MS_CASS(0x6),                                                   \
 171         MS_RET(0)                                                       \
 172 }
 173
 174 #define INB_NIBBLE_L MS_PARAM(3, 2, MS_TYP_PTR)
 175 #define INB_NIBBLE_H MS_PARAM(6, 2, MS_TYP_PTR)
 176 #define INB_NIBBLE_F MS_PARAM(9, 0, MS_TYP_FUN)
 177 #define INB_NIBBLE_P MS_PARAM(9, 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         MS_CASS(0x4),                                                   \
 188 /* loop: */                                                             \
 189         MS_CASS(0x6),                                                   \
 190         MS_DELAY(1),                                                    \
 191         MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* low nibble */),\
 192         MS_CASS(0x5),                                                   \
 193         MS_DELAY(1),                                                    \
 194         MS_RFETCH(MS_REG_STR, MS_FETCH_ALL, MS_UNKNOWN /* high nibble */),\
 195         MS_CASS(0x4),                                                   \
 196         MS_DELAY(1),                                                    \
 197         /* do a C call to format the received nibbles */                \
 198         MS_C_CALL(MS_UNKNOWN /* C hook */, MS_UNKNOWN /* param */),     \
 199         MS_DBRA(-7 /* loop */),                                         \
 200         MS_RET(0)                                                       \
 201 }
 202
 203 static struct ppb_microseq reset_microseq[] = {
 204         MS_CASS(0x04),
 205         MS_DASS(0x40),
 206         MS_DELAY(1),
 207         MS_CASS(0x0c),
 208         MS_CASS(0x0d),
 209         MS_DELAY(50),
 210         MS_CASS(0x0c),
 211         MS_CASS(0x04),
 212         MS_RET(0)
 213 };
 214
 215 /*
 216  * nibble_inbyte_hook()
 217  *
 218  * Formats high and low nibble into a character
 219  */
 220 static int
 221 nibble_inbyte_hook (void *p, char *ptr)
 222 {
 223         struct vpo_nibble *s = (struct vpo_nibble *)p;
 224
 225         /* increment the buffer pointer */
 226         *ptr = ((s->l >> 4) & 0x0f) + (s->h & 0xf0);
 227
 228         return (0);
 229 }
 230
 231 /*
 232  * This is the sub-microseqence for MS_GET in PS2 mode
 233  */
 234 static struct ppb_microseq ps2_inbyte_submicroseq[] = {
 235           MS_CASS(0x4),
 236
 237 /* loop: */
 238           MS_CASS(PCD | 0x6),
 239           MS_RFETCH_P(1, MS_REG_DTR, MS_FETCH_ALL),
 240           MS_CASS(PCD | 0x5),
 241           MS_DBRA(-4 /* loop */),
 242
 243           MS_RET(0)
 244 };
 245
 246 /*
 247  * This is the sub-microsequence for MS_PUT in both NIBBLE and PS2 modes
 248  */
 249 static struct ppb_microseq spp_outbyte_submicroseq[] = {
 250           MS_CASS(0x4),
 251
 252 /* loop: */
 253           MS_RASSERT_P(1, MS_REG_DTR),
 254           MS_CASS(0x5),
 255           MS_DBRA(0),                           /* decrement counter */
 256           MS_RASSERT_P(1, MS_REG_DTR),
 257           MS_CASS(0x0),
 258           MS_DBRA(-6 /* loop */),
 259
 260           /* return from the put call */
 261           MS_CASS(0x4),
 262           MS_RET(0)
 263 };
 264
 265 /* EPP 1.7 microsequences, ptr and len set at runtime */
 266 static struct ppb_microseq epp17_outstr[] = {
 267           MS_CASS(0x4),
 268           MS_RASSERT_P(MS_ACCUM, MS_REG_EPP_D),
 269           MS_CASS(0xc),
 270           MS_RET(0),
 271 };
 272
 273 static struct ppb_microseq epp17_instr[] = {
 274           MS_CASS(PCD | 0x4),
 275           MS_RFETCH_P(MS_ACCUM, MS_REG_EPP_D, MS_FETCH_ALL),
 276           MS_CASS(PCD | 0xc),
 277           MS_RET(0),
 278 };
 279
 280 static int
 281 imm_disconnect(struct vpoio_data *vpo, int *connected, int release_bus)
 282 {
 283         DECLARE_CPP_MICROSEQ;
 284
 285         device_t ppbus = device_get_parent(vpo->vpo_dev);
 286         char s1, s2, s3;
 287         int ret;
 288
 289         /* all should be ok */
 290         if (connected)
 291                 *connected = 0;
 292
 293         ppb_MS_init_msq(cpp_microseq, 4, CPP_S1, (void *)&s1,
 294                         CPP_S2, (void *)&s2, CPP_S3, (void *)&s3,
 295                         CPP_PARAM, 0x30);
 296
 297         ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret);
 298
 299         if ((s1 != (char)0xb8 || s2 != (char)0x18 || s3 != (char)0x38)) {
 300                 if (bootverbose)
 301                         device_printf(vpo->vpo_dev,
 302                             "(disconnect) s1=0x%x s2=0x%x, s3=0x%x\n",
 303                             s1 & 0xff, s2 & 0xff, s3 & 0xff);
 304                 if (connected)
 305                         *connected = VP0_ECONNECT;
 306         }
 307
 308         if (release_bus)
 309                 return (ppb_release_bus(ppbus, vpo->vpo_dev));
 310         else
 311                 return (0);
 312 }
 313
 314 /*
 315  * how  : PPB_WAIT or PPB_DONTWAIT
 316  */
 317 static int
 318 imm_connect(struct vpoio_data *vpo, int how, int *disconnected, int request_bus)
 319 {
 320         DECLARE_CPP_MICROSEQ;
 321
 322         device_t ppbus = device_get_parent(vpo->vpo_dev);
 323         char s1, s2, s3;
 324         int error;
 325         int ret;
 326
 327         /* all should be ok */
 328         if (disconnected)
 329                 *disconnected = 0;
 330
 331         if (request_bus)
 332                 if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, how)))
 333                         return (error);
 334
 335         ppb_MS_init_msq(cpp_microseq, 3, CPP_S1, (void *)&s1,
 336                         CPP_S2, (void *)&s2, CPP_S3, (void *)&s3);
 337
 338         /* select device 0 in compatible mode */
 339         ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0xe0);
 340         ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret);
 341
 342         /* disconnect all devices */
 343         ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0x30);
 344         ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret);
 345
 346         if (PPB_IN_EPP_MODE(ppbus))
 347                 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0x28);
 348         else
 349                 ppb_MS_init_msq(cpp_microseq, 1, CPP_PARAM, 0xe0);
 350
 351         ppb_MS_microseq(ppbus, vpo->vpo_dev, cpp_microseq, &ret);
 352
 353         if ((s1 != (char)0xb8 || s2 != (char)0x18 || s3 != (char)0x30)) {
 354                 if (bootverbose)
 355                         device_printf(vpo->vpo_dev,
 356                             "(connect) s1=0x%x s2=0x%x, s3=0x%x\n",
 357                             s1 & 0xff, s2 & 0xff, s3 & 0xff);
 358                 if (disconnected)
 359                         *disconnected = VP0_ECONNECT;
 360         }
 361
 362         return (0);
 363 }
 364
 365 /*
 366  * imm_detect()
 367  *
 368  * Detect and initialise the VP0 adapter.
 369  */
 370 static int
 371 imm_detect(struct vpoio_data *vpo)
 372 {
 373         device_t ppbus = device_get_parent(vpo->vpo_dev);
 374         int error;
 375
 376         if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_DONTWAIT)))
 377                 return (error);
 378
 379         /* disconnect the drive, keep the bus */
 380         imm_disconnect(vpo, NULL, 0);
 381
 382         vpo->vpo_mode_found = VP0_MODE_UNDEFINED;
 383         error = 1;
 384
 385         /* try to enter EPP mode since vpoio failure put the bus in NIBBLE */
 386         if (ppb_set_mode(ppbus, PPB_EPP) != -1) {
 387                 imm_connect(vpo, PPB_DONTWAIT, &error, 0);
 388         }
 389
 390         /* if connection failed try PS/2 then NIBBLE modes */
 391         if (error) {
 392                 if (ppb_set_mode(ppbus, PPB_PS2) != -1) {
 393                         imm_connect(vpo, PPB_DONTWAIT, &error, 0);
 394                 }
 395                 if (error) {
 396                         if (ppb_set_mode(ppbus, PPB_NIBBLE) != -1) {
 397                                 imm_connect(vpo, PPB_DONTWAIT, &error, 0);
 398                                 if (error)
 399                                         goto error;
 400                                 vpo->vpo_mode_found = VP0_MODE_NIBBLE;
 401                         } else {
 402                                 device_printf(vpo->vpo_dev,
 403                                     "NIBBLE mode unavailable!\n");
 404                                 goto error;
 405                         }
 406                 } else {
 407                         vpo->vpo_mode_found = VP0_MODE_PS2;
 408                 }
 409         } else {
 410                 vpo->vpo_mode_found = VP0_MODE_EPP;
 411         }
 412
 413         /* send SCSI reset signal */
 414         ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, NULL);
 415
 416         /* release the bus now */
 417         imm_disconnect(vpo, &error, 1);
 418
 419         /* ensure we are disconnected or daisy chained peripheral
 420          * may cause serious problem to the disk */
 421
 422         if (error) {
 423                 if (bootverbose)
 424                         device_printf(vpo->vpo_dev,
 425                             "can't disconnect from the drive\n");
 426                 goto error;
 427         }
 428
 429         return (0);
 430
 431 error:
 432         ppb_release_bus(ppbus, vpo->vpo_dev);
 433         return (VP0_EINITFAILED);
 434 }
 435
 436 /*
 437  * imm_outstr()
 438  */
 439 static int
 440 imm_outstr(struct vpoio_data *vpo, char *buffer, int size)
 441 {
 442         device_t ppbus = device_get_parent(vpo->vpo_dev);
 443         int error = 0;
 444
 445         if (PPB_IN_EPP_MODE(ppbus))
 446                 ppb_reset_epp_timeout(ppbus);
 447
 448         ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_PUT, (union ppb_insarg)buffer,
 449                 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error);
 450
 451         return (error);
 452 }
 453
 454 /*
 455  * imm_instr()
 456  */
 457 static int
 458 imm_instr(struct vpoio_data *vpo, char *buffer, int size)
 459 {
 460         device_t ppbus = device_get_parent(vpo->vpo_dev);
 461         int error = 0;
 462
 463         if (PPB_IN_EPP_MODE(ppbus))
 464                 ppb_reset_epp_timeout(ppbus);
 465
 466         ppb_MS_exec(ppbus, vpo->vpo_dev, MS_OP_GET, (union ppb_insarg)buffer,
 467                 (union ppb_insarg)size, (union ppb_insarg)MS_UNKNOWN, &error);
 468
 469         return (error);
 470 }
 471
 472 static char
 473 imm_select(struct vpoio_data *vpo, int initiator, int target)
 474 {
 475         DECLARE_SELECT_MICROSEQUENCE;
 476         device_t ppbus = device_get_parent(vpo->vpo_dev);
 477         int ret;
 478
 479         /* initialize the select microsequence */
 480         ppb_MS_init_msq(select_microseq, 1,
 481                         SELECT_TARGET, 1 << initiator | 1 << target);
 482
 483         ppb_MS_microseq(ppbus, vpo->vpo_dev, select_microseq, &ret);
 484
 485         return (ret);
 486 }
 487
 488 /*
 489  * imm_wait()
 490  *
 491  * H_SELIN must be low.
 492  *
 493  */
 494 static char
 495 imm_wait(struct vpoio_data *vpo, int tmo)
 496 {
 497         DECLARE_WAIT_MICROSEQUENCE;
 498
 499         device_t ppbus = device_get_parent(vpo->vpo_dev);
 500         int ret, err;
 501
 502         /*
 503          * Return some status information.
 504          * Semantics :  0x88 = ZIP+ wants more data
 505          *              0x98 = ZIP+ wants to send more data
 506          *              0xa8 = ZIP+ wants command
 507          *              0xb8 = end of transfer, ZIP+ is sending status
 508          */
 509
 510         ppb_MS_init_msq(wait_microseq, 2,
 511                         WAIT_RET, (void *)&ret,
 512                         WAIT_TMO, tmo);
 513
 514         ppb_MS_microseq(ppbus, vpo->vpo_dev, wait_microseq, &err);
 515
 516         if (err)
 517                 return (0);                        /* command timed out */
 518
 519         return(ret);
 520 }
 521
 522 static int
 523 imm_negociate(struct vpoio_data *vpo)
 524 {
 525         DECLARE_NEGOCIATE_MICROSEQ;
 526         device_t ppbus = device_get_parent(vpo->vpo_dev);
 527         int negociate_mode;
 528         int ret;
 529
 530         if (PPB_IN_NIBBLE_MODE(ppbus))
 531                 negociate_mode = 0;
 532         else if (PPB_IN_PS2_MODE(ppbus))
 533                 negociate_mode = 1;
 534         else
 535                 return (0);
 536
 537 #if 0 /* XXX use standalone code not to depend on ppb_1284 code yet */
 538         ret = ppb_1284_negociate(ppbus, negociate_mode);
 539
 540         if (ret)
 541                 return (VP0_ENEGOCIATE);
 542 #endif
 543
 544         ppb_MS_init_msq(negociate_microseq, 1,
 545                         NEGOCIATED_MODE, negociate_mode);
 546
 547         ppb_MS_microseq(ppbus, vpo->vpo_dev, negociate_microseq, &ret);
 548
 549         return (ret);
 550 }
 551
 552 /*
 553  * imm_probe()
 554  *
 555  * Low level probe of vpo device
 556  *
 557  */
 558 int
 559 imm_probe(device_t dev, struct vpoio_data *vpo)
 560 {
 561         int error;
 562
 563         /* ppbus dependent initialisation */
 564         vpo->vpo_dev = dev;
 565
 566         /* now, try to initialise the drive */
 567         if ((error = imm_detect(vpo))) {
 568                 return (error);
 569         }
 570
 571         return (0);
 572 }
 573
 574 /*
 575  * imm_attach()
 576  *
 577  * Low level attachment of vpo device
 578  *
 579  */
 580 int
 581 imm_attach(struct vpoio_data *vpo)
 582 {
 583         DECLARE_NIBBLE_INBYTE_SUBMICROSEQ;
 584         device_t ppbus = device_get_parent(vpo->vpo_dev);
 585         int error = 0;
 586
 587         /*
 588          * Initialize microsequence code
 589          */
 590         vpo->vpo_nibble_inbyte_msq = (struct ppb_microseq *)malloc(
 591                 sizeof(nibble_inbyte_submicroseq), M_DEVBUF, M_NOWAIT);
 592
 593         if (!vpo->vpo_nibble_inbyte_msq)
 594                 return (ENXIO);
 595
 596         bcopy((void *)nibble_inbyte_submicroseq,
 597                 (void *)vpo->vpo_nibble_inbyte_msq,
 598                 sizeof(nibble_inbyte_submicroseq));
 599
 600         ppb_MS_init_msq(vpo->vpo_nibble_inbyte_msq, 4,
 601                 INB_NIBBLE_H, (void *)&(vpo)->vpo_nibble.h,
 602                 INB_NIBBLE_L, (void *)&(vpo)->vpo_nibble.l,
 603                 INB_NIBBLE_F, nibble_inbyte_hook,
 604                 INB_NIBBLE_P, (void *)&(vpo)->vpo_nibble);
 605
 606         /*
 607          * Initialize mode dependent in/out microsequences
 608          */
 609         ppb_lock(ppbus);
 610         if ((error = ppb_request_bus(ppbus, vpo->vpo_dev, PPB_WAIT)))
 611             goto error;
 612
 613         /* ppbus automatically restore the last mode entered during detection */
 614         switch (vpo->vpo_mode_found) {
 615         case VP0_MODE_EPP:
 616                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, epp17_instr);
 617                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, epp17_outstr);
 618                 device_printf(vpo->vpo_dev, "EPP mode\n");
 619                 break;
 620         case VP0_MODE_PS2:
 621                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, ps2_inbyte_submicroseq);
 622                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
 623                 device_printf(vpo->vpo_dev, "PS2 mode\n");
 624                 break;
 625         case VP0_MODE_NIBBLE:
 626                 ppb_MS_GET_init(ppbus, vpo->vpo_dev, vpo->vpo_nibble_inbyte_msq);
 627                 ppb_MS_PUT_init(ppbus, vpo->vpo_dev, spp_outbyte_submicroseq);
 628                 device_printf(vpo->vpo_dev, "NIBBLE mode\n");
 629                 break;
 630         default:
 631                 panic("imm: unknown mode %d", vpo->vpo_mode_found);
 632         }
 633
 634         ppb_release_bus(ppbus, vpo->vpo_dev);
 635  error:
 636         ppb_unlock(ppbus);
 637         return (error);
 638 }
 639
 640 /*
 641  * imm_reset_bus()
 642  *
 643  */
 644 int
 645 imm_reset_bus(struct vpoio_data *vpo)
 646 {
 647         device_t ppbus = device_get_parent(vpo->vpo_dev);
 648         int disconnected;
 649
 650         /* first, connect to the drive and request the bus */
 651         imm_connect(vpo, PPB_WAIT|PPB_INTR, &disconnected, 1);
 652
 653         if (!disconnected) {
 654
 655                 /* reset the SCSI bus */
 656                 ppb_MS_microseq(ppbus, vpo->vpo_dev, reset_microseq, NULL);
 657
 658                 /* then disconnect */
 659                 imm_disconnect(vpo, NULL, 1);
 660         }
 661
 662         return (0);
 663 }
 664
 665 /*
 666  * imm_do_scsi()
 667  *
 668  * Send an SCSI command
 669  *
 670  */
 671 int
 672 imm_do_scsi(struct vpoio_data *vpo, int host, int target, char *command,
 673                 int clen, char *buffer, int blen, int *result, int *count,
 674                 int *ret)
 675 {
 676         device_t ppbus = device_get_parent(vpo->vpo_dev);
 677         register char r;
 678         char l, h = 0;
 679         int len, error = 0, not_connected = 0;
 680         register int k;
 681         int negociated = 0;
 682
 683         /*
 684          * enter disk state, allocate the ppbus
 685          *
 686          * XXX
 687          * Should we allow this call to be interruptible?
 688          * The only way to report the interruption is to return
 689          * EIO to upper SCSI code :^(
 690          */
 691         if ((error = imm_connect(vpo, PPB_WAIT|PPB_INTR, &not_connected, 1)))
 692                 return (error);
 693
 694         if (not_connected) {
 695                 *ret = VP0_ECONNECT;
 696                 goto error;
 697         }
 698
 699         /*
 700          * Select the drive ...
 701          */
 702         if ((*ret = imm_select(vpo,host,target)))
 703                 goto error;
 704
 705         /*
 706          * Send the command ...
 707          */
 708         for (k = 0; k < clen; k+=2) {
 709                 if (imm_wait(vpo, VP0_FAST_SPINTMO) != (char)0xa8) {
 710                         *ret = VP0_ECMD_TIMEOUT;
 711                         goto error;
 712                 }
 713                 if (imm_outstr(vpo, &command[k], 2)) {
 714                         *ret = VP0_EPPDATA_TIMEOUT;
 715                         goto error;
 716                 }
 717         }
 718
 719         if (!(r = imm_wait(vpo, VP0_LOW_SPINTMO))) {
 720                 *ret = VP0_ESTATUS_TIMEOUT;
 721                 goto error;
 722         }
 723
 724         if ((r & 0x30) == 0x10) {
 725                 if (imm_negociate(vpo)) {
 726                         *ret = VP0_ENEGOCIATE;
 727                         goto error;
 728                 } else
 729                         negociated = 1;
 730         }
 731
 732         /*
 733          * Complete transfer ...
 734          */
 735         *count = 0;
 736         for (;;) {
 737
 738                 if (!(r = imm_wait(vpo, VP0_LOW_SPINTMO))) {
 739                         *ret = VP0_ESTATUS_TIMEOUT;
 740                         goto error;
 741                 }
 742
 743                 /* stop when the ZIP+ wants to send status */
 744                 if (r == (char)0xb8)
 745                         break;
 746
 747                 if (*count >= blen) {
 748                         *ret = VP0_EDATA_OVERFLOW;
 749                         goto error;
 750                 }
 751
 752                 /* ZIP+ wants to send data? */
 753                 if (r == (char)0x88) {
 754                         len = (((blen - *count) >= VP0_SECTOR_SIZE)) ?
 755                                 VP0_SECTOR_SIZE : 2;
 756
 757                         error = imm_outstr(vpo, &buffer[*count], len);
 758                 } else {
 759                         if (!PPB_IN_EPP_MODE(ppbus))
 760                                 len = 1;
 761                         else
 762                                 len = (((blen - *count) >= VP0_SECTOR_SIZE)) ?
 763                                         VP0_SECTOR_SIZE : 1;
 764
 765                         error = imm_instr(vpo, &buffer[*count], len);
 766                 }
 767
 768                 if (error) {
 769                         *ret = error;
 770                         goto error;
 771                 }
 772
 773                 *count += len;
 774         }
 775
 776         if ((PPB_IN_NIBBLE_MODE(ppbus) ||
 777                         PPB_IN_PS2_MODE(ppbus)) && negociated)
 778                 ppb_MS_microseq(ppbus, vpo->vpo_dev, transfer_epilog, NULL);
 779
 780         /*
 781          * Retrieve status ...
 782          */
 783         if (imm_negociate(vpo)) {
 784                 *ret = VP0_ENEGOCIATE;
 785                 goto error;
 786         } else
 787                 negociated = 1;
 788
 789         if (imm_instr(vpo, &l, 1)) {
 790                 *ret = VP0_EOTHER;
 791                 goto error;
 792         }
 793
 794         /* check if the ZIP+ wants to send more status */
 795         if (imm_wait(vpo, VP0_FAST_SPINTMO) == (char)0xb8)
 796                 if (imm_instr(vpo, &h, 1)) {
 797                         *ret = VP0_EOTHER + 2;
 798                         goto error;
 799                 }
 800
 801         /* Experience showed that we should discard this */
 802         if (h == (char) -1)
 803                 h = 0;
 804
 805         *result = ((int) h << 8) | ((int) l & 0xff);
 806
 807 error:
 808         if ((PPB_IN_NIBBLE_MODE(ppbus) ||
 809                         PPB_IN_PS2_MODE(ppbus)) && negociated)
 810                 ppb_MS_microseq(ppbus, vpo->vpo_dev, transfer_epilog, NULL);
 811
 812         /* return to printer state, release the ppbus */
 813         imm_disconnect(vpo, NULL, 1);
 814
 815         return (0);
 816 }