sys/dev/ppbus/ppbus_1284.c

   1 /* $NetBSD: ppbus_1284.c,v 1.11 2008/04/15 15:02:29 cegger Exp $ */
   2
   3 /*-
   4  * Copyright (c) 1997 Nicolas Souchu
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  * FreeBSD: src/sys/dev/ppbus/ppb_1284.c,v 1.11 2000/01/14 08:03:14 nsouch Exp
  29  *
  30  */
  31
  32 /* General purpose routines for the IEEE1284-1994 Standard */
  33
  34 #include <sys/cdefs.h>
  35 __KERNEL_RCSID(0, "$NetBSD: ppbus_1284.c,v 1.11 2008/04/15 15:02:29 cegger Exp $");
  36
  37 #include "opt_ppbus_1284.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/malloc.h>
  41 #include <sys/systm.h>
  42
  43 #include <dev/ppbus/ppbus_conf.h>
  44 #include <dev/ppbus/ppbus_base.h>
  45 #include <dev/ppbus/ppbus_1284.h>
  46 #include <dev/ppbus/ppbus_io.h>
  47 #include <dev/ppbus/ppbus_var.h>
  48
  49
  50 /* Wait for the peripherial up to 40ms */
  51 static int
  52 do_1284_wait(struct ppbus_softc * bus, char mask, char status)
  53 {
  54         return (ppbus_poll_bus(bus->sc_dev, 4, mask, status,
  55                 PPBUS_NOINTR | PPBUS_POLL));
  56 }
  57
  58 /* Wait for the host up to 1 second (peripheral side) */
  59 static int
  60 do_peripheral_wait(struct ppbus_softc * bus, char mask, char status)
  61 {
  62         return (ppbus_poll_bus(bus->sc_dev, 100, mask, status,
  63                 PPBUS_NOINTR | PPBUS_POLL));
  64 }
  65
  66
  67 /* Unconditionaly reset the error field */
  68 static int
  69 ppbus_1284_reset_error(struct ppbus_softc * bus, int state)
  70 {
  71         bus->sc_1284_error = PPBUS_NO_ERROR;
  72         bus->sc_1284_state = state;
  73         return 0;
  74 }
  75
  76
  77 /* Get IEEE1284 state */
  78 int
  79 ppbus_1284_get_state(device_t dev)
  80 {
  81         struct ppbus_softc *sc = device_private(dev);
  82
  83         return sc->sc_1284_state;
  84 }
  85
  86
  87 /* Set IEEE1284 state if no error occurred */
  88 int
  89 ppbus_1284_set_state(device_t dev, int state)
  90 {
  91         struct ppbus_softc * bus = device_private(dev);
  92
  93         /* call ppbus_1284_reset_error() if you absolutly want to change
  94          * the state from PPBUS_ERROR to another */
  95         if ((bus->sc_1284_state != PPBUS_ERROR) &&
  96                         (bus->sc_1284_error == PPBUS_NO_ERROR)) {
  97                 bus->sc_1284_state = state;
  98                 bus->sc_1284_error = PPBUS_NO_ERROR;
  99         }
 100
 101         return 0;
 102 }
 103
 104
 105 /* Set the IEEE1284 error field */
 106 static int
 107 ppbus_1284_set_error(struct ppbus_softc * bus, int error, int event)
 108 {
 109         /* do not accumulate errors */
 110         if ((bus->sc_1284_error == PPBUS_NO_ERROR) &&
 111                         (bus->sc_1284_state != PPBUS_ERROR)) {
 112                 bus->sc_1284_error = error;
 113                 bus->sc_1284_state = PPBUS_ERROR;
 114         }
 115
 116 #ifdef DEBUG_1284
 117         printf("%s<1284>: error=%d status=0x%x event=%d\n",
 118                 device_xname(bus->sc_dev), error, ppbus_rstr(bus->sc_dev),
 119                 event);
 120
 121 #endif
 122
 123         return 0;
 124 }
 125
 126
 127 /* Converts mode+options into ext. value */
 128 static int
 129 ppbus_request_mode(int mode, int options)
 130 {
 131         int request_mode = 0;
 132
 133         if (options & PPBUS_EXTENSIBILITY_LINK) {
 134                 request_mode = EXT_LINK_1284_NORMAL;
 135
 136         }
 137         else {
 138                 switch (mode) {
 139                 case PPBUS_NIBBLE:
 140                         request_mode = (options & PPBUS_REQUEST_ID) ?
 141                                         NIBBLE_1284_REQUEST_ID :
 142                                         NIBBLE_1284_NORMAL;
 143                         break;
 144                 case PPBUS_PS2:
 145                         request_mode = (options & PPBUS_REQUEST_ID) ?
 146                                         BYTE_1284_REQUEST_ID :
 147                                         BYTE_1284_NORMAL;
 148                         break;
 149                 case PPBUS_ECP:
 150                         if (options & PPBUS_USE_RLE)
 151                                 request_mode = (options & PPBUS_REQUEST_ID) ?
 152                                         ECP_1284_RLE_REQUEST_ID :
 153                                         ECP_1284_RLE;
 154                         else
 155                                 request_mode = (options & PPBUS_REQUEST_ID) ?
 156                                         ECP_1284_REQUEST_ID :
 157                                         ECP_1284_NORMAL;
 158                         break;
 159                 case PPBUS_EPP:
 160                         request_mode = EPP_1284_NORMAL;
 161                         break;
 162                 default:
 163                         panic("%s: unsupported mode %d\n", __func__, mode);
 164                 }
 165         }
 166
 167         return (request_mode);
 168 }
 169
 170
 171 /* Negotiate the peripheral side */
 172 int
 173 ppbus_peripheral_negotiate(device_t dev, int mode, int options)
 174 {
 175         struct ppbus_softc * bus = device_private(dev);
 176         int spin, request_mode, error = 0;
 177         char r;
 178
 179         ppbus_1284_terminate(dev);
 180         ppbus_1284_set_state(dev, PPBUS_PERIPHERAL_NEGOTIATION);
 181
 182         /* compute ext. value */
 183         request_mode = ppbus_request_mode(mode, options);
 184
 185         /* wait host */
 186         spin = 10;
 187         while (spin-- && (ppbus_rstr(dev) & nBUSY))
 188                 DELAY(1);
 189
 190         /* check termination */
 191         if (!(ppbus_rstr(dev) & SELECT) || !spin) {
 192                 error = ENODEV;
 193                 goto error;
 194         }
 195
 196         /* Event 4 - read ext. value */
 197         r = ppbus_rdtr(dev);
 198
 199         /* nibble mode is not supported */
 200         if ((r == (char)request_mode) ||
 201                         (r == NIBBLE_1284_NORMAL)) {
 202
 203                 /* Event 5 - restore direction bit, no data avail */
 204                 ppbus_wctr(dev, (STROBE | nINIT) & ~(SELECTIN));
 205                 DELAY(1);
 206
 207                 /* Event 6 */
 208                 ppbus_wctr(dev, (nINIT) & ~(SELECTIN | STROBE));
 209
 210                 if (r == NIBBLE_1284_NORMAL) {
 211 #ifdef DEBUG_1284
 212                         printf("R");
 213 #endif
 214                         ppbus_1284_set_error(bus, PPBUS_MODE_UNSUPPORTED, 4);
 215                         error = EINVAL;
 216                         goto error;
 217                 }
 218                 else {
 219                         ppbus_1284_set_state(dev, PPBUS_PERIPHERAL_IDLE);
 220 #ifdef DEBUG_1284
 221                         printf("A");
 222 #endif
 223                         /* negotiation succeeds */
 224                 }
 225         }
 226         else {
 227                 /* Event 5 - mode not supported */
 228                 ppbus_wctr(dev, SELECTIN);
 229                 DELAY(1);
 230
 231                 /* Event 6 */
 232                 ppbus_wctr(dev, (SELECTIN) & ~(STROBE | nINIT));
 233                 ppbus_1284_set_error(bus, PPBUS_MODE_UNSUPPORTED, 4);
 234
 235 #ifdef DEBUG_1284
 236                 printf("r");
 237 #endif
 238                 error = EINVAL;
 239                 goto error;
 240         }
 241
 242         return (0);
 243
 244 error:
 245         ppbus_peripheral_terminate(dev, PPBUS_WAIT);
 246         return (error);
 247 }
 248
 249
 250 /* Terminate peripheral transfer side. Always return 0 in compatible mode */
 251 int
 252 ppbus_peripheral_terminate(device_t dev, int how)
 253 {
 254         struct ppbus_softc * bus = device_private(dev);
 255         int error = 0;
 256
 257 #ifdef DEBUG_1284
 258         printf("t");
 259 #endif
 260
 261         ppbus_1284_set_state(dev, PPBUS_PERIPHERAL_TERMINATION);
 262
 263         /* Event 22 - wait up to host response time (1s) */
 264         if ((error = do_peripheral_wait(bus, SELECT | nBUSY, 0))) {
 265                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 22);
 266                 goto error;
 267         }
 268
 269         /* Event 24 */
 270         ppbus_wctr(dev, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN));
 271
 272         /* Event 25 - wait up to host response time (1s) */
 273         if ((error = do_peripheral_wait(bus, nBUSY, nBUSY))) {
 274                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 25);
 275                 goto error;
 276         }
 277
 278         /* Event 26 */
 279         ppbus_wctr(dev, (SELECTIN | nINIT | STROBE) & ~(AUTOFEED));
 280         DELAY(1);
 281         /* Event 27 */
 282         ppbus_wctr(dev, (SELECTIN | nINIT) & ~(STROBE | AUTOFEED));
 283
 284         /* Event 28 - wait up to host response time (1s) */
 285         if ((error = do_peripheral_wait(bus, nBUSY, 0))) {
 286                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 28);
 287                 goto error;
 288         }
 289
 290 error:
 291         ppbus_1284_terminate(dev);
 292         ppbus_1284_set_state(dev, PPBUS_FORWARD_IDLE);
 293
 294         return (0);
 295 }
 296
 297
 298 /* Write 1 byte to host in BYTE mode (peripheral side) */
 299 static int
 300 byte_peripheral_outbyte(device_t dev, char *buffer, int last)
 301 {
 302         struct ppbus_softc * bus = device_private(dev);
 303         int error = 0;
 304
 305         /* Event 7 */
 306         if ((error = do_1284_wait(bus, nBUSY, nBUSY))) {
 307                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 7);
 308                 goto error;
 309         }
 310
 311         /* check termination */
 312         if (!(ppbus_rstr(dev) & SELECT)) {
 313                 ppbus_peripheral_terminate(dev, PPBUS_WAIT);
 314                 goto error;
 315         }
 316
 317         /* Event 15 - put byte on data lines */
 318 #ifdef DEBUG_1284
 319         printf("B");
 320 #endif
 321         ppbus_wdtr(dev, *buffer);
 322
 323         /* Event 9 */
 324         ppbus_wctr(dev, (AUTOFEED | STROBE) & ~(nINIT | SELECTIN));
 325
 326         /* Event 10 - wait data read */
 327         if ((error = do_peripheral_wait(bus, nBUSY, 0))) {
 328                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 16);
 329                 goto error;
 330         }
 331
 332         /* Event 11 */
 333         if (!last) {
 334                 ppbus_wctr(dev, (AUTOFEED) & ~(nINIT | STROBE | SELECTIN));
 335         } else {
 336                 ppbus_wctr(dev, (nINIT) & ~(STROBE | SELECTIN | AUTOFEED));
 337         }
 338
 339 #if 0
 340         /* Event 16 - wait strobe */
 341         if ((error = do_peripheral_wait(bus, nACK | nBUSY, 0))) {
 342                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 16);
 343                 goto error;
 344         }
 345 #endif
 346
 347         /* check termination */
 348         if (!(ppbus_rstr(dev) & SELECT)) {
 349                 ppbus_peripheral_terminate(dev, PPBUS_WAIT);
 350                 goto error;
 351         }
 352
 353 error:
 354         return (error);
 355 }
 356
 357
 358 /* Write n bytes to host in BYTE mode (peripheral side) */
 359 int
 360 byte_peripheral_write(device_t dev, char *buffer, int len,
 361         int *sent)
 362 {
 363         int error = 0, i;
 364         char r;
 365
 366         ppbus_1284_set_state(dev, PPBUS_PERIPHERAL_TRANSFER);
 367
 368         /* wait forever, the remote host is master and should initiate
 369          * termination
 370          */
 371         for(i = 0; i < len; i++) {
 372                 /* force remote nFAULT low to release the remote waiting
 373                  * process, if any
 374                  */
 375                 r = ppbus_rctr(dev);
 376                 ppbus_wctr(dev, r & ~nINIT);
 377
 378 #ifdef DEBUG_1284
 379                 printf("y");
 380 #endif
 381                 /* Event 7 */
 382                 error = ppbus_poll_bus(dev, PPBUS_FOREVER, nBUSY, nBUSY,
 383                                         PPBUS_INTR);
 384
 385                 if (error && error != EWOULDBLOCK)
 386                         goto error;
 387
 388 #ifdef DEBUG_1284
 389                 printf("b");
 390 #endif
 391                 if ((error = byte_peripheral_outbyte(dev, buffer+i, (i == len-1))))
 392                         goto error;
 393         }
 394 error:
 395         if (!error)
 396                 ppbus_1284_set_state(dev, PPBUS_PERIPHERAL_IDLE);
 397
 398         *sent = i;
 399         return (error);
 400 }
 401
 402
 403 /* Read the device ID using the specified mode */
 404 int
 405 ppbus_1284_read_id(device_t dev, int mode, char ** buffer,
 406                 size_t * size, size_t * read)
 407 {
 408         u_int16_t msg_sz;
 409         u_int8_t length_field;
 410         u_int8_t old_mode;
 411         int error;
 412         int old_ivar;
 413         int new_ivar = 1;
 414
 415         error = ppbus_read_ivar(dev, PPBUS_IVAR_IEEE, &old_ivar);
 416         if(error) {
 417                 printf("%s(%s): error reading PPBUS_IVAR_IEEE.\n", __func__,
 418                         device_xname(dev));
 419                 return error;
 420         }
 421         if(old_ivar == 0) {
 422                 error = ppbus_write_ivar(dev, PPBUS_IVAR_IEEE, &new_ivar);
 423                 if(error) {
 424                         printf("%s(%s): error enabling IEEE usage.\n", __func__,
 425                                 device_xname(dev));
 426                         return error;
 427                 }
 428         }
 429
 430         old_mode = ppbus_get_mode(dev);
 431         switch (mode) {
 432         case PPBUS_NIBBLE:
 433         case PPBUS_ECP:
 434         case PPBUS_BYTE:
 435                 error = ppbus_set_mode(dev, mode, PPBUS_REQUEST_ID);
 436                 if(error) {
 437                         printf("%s(%s): error setting bus mode.\n", __func__,
 438                                 device_xname(dev));
 439                         goto end_read_id;
 440                 }
 441                 break;
 442         default:
 443                 printf("%s(%s): mode does not support returning device ID.\n",
 444                         __func__, device_xname(dev));
 445                 error = ENODEV;
 446                 goto end_read_id;
 447         }
 448
 449         error = ppbus_read(dev, &length_field, 1, 0, read);
 450         if(error) {
 451                 printf("%s(%s): error reading first byte.\n", __func__,
 452                         device_xname(dev));
 453                 goto end_read_id;
 454         }
 455         msg_sz = length_field;
 456         error = ppbus_read(dev, &length_field, 1, 0, read);
 457         if(error) {
 458                 printf("%s(%s): error reading second byte.\n",
 459                         __func__, device_xname(dev));
 460                 goto end_read_id;
 461         }
 462         msg_sz <<= 8;
 463         msg_sz |= length_field;
 464         msg_sz -= 2;
 465         if(msg_sz <= 0) {
 466                 printf("%s(%s): device ID length <= 0.\n", __func__,
 467                         device_xname(dev));
 468                 goto end_read_id;
 469         }
 470         *buffer = malloc(msg_sz, M_DEVBUF, M_WAITOK);
 471         *size = msg_sz;
 472         error = ppbus_read(dev, *buffer, msg_sz, 0, read);
 473
 474 end_read_id:
 475         ppbus_set_mode(dev, old_mode, 0);
 476         if(old_ivar == 0) {
 477                 if(ppbus_write_ivar(dev, PPBUS_IVAR_IEEE, &old_ivar)) {
 478                         printf("%s(%s): error restoring PPBUS_IVAR_IEEE.\n",
 479                                 __func__, device_xname(dev));
 480                 }
 481         }
 482         return (error);
 483 }
 484
 485 /*
 486  * IEEE1284 negotiation phase: after negotiation, nFAULT is low if data is
 487  * available for reverse modes.
 488  */
 489 int
 490 ppbus_1284_negotiate(device_t dev, int mode, int options)
 491 {
 492         struct ppbus_softc * bus = device_private(dev);
 493         int error;
 494         int request_mode;
 495
 496 #ifdef DEBUG_1284
 497         printf("n");
 498 #endif
 499
 500         if (ppbus_1284_get_state(dev) >= PPBUS_PERIPHERAL_NEGOTIATION)
 501                 ppbus_peripheral_terminate(dev, PPBUS_WAIT);
 502
 503 #ifdef DEBUG_1284
 504         printf("%d", mode);
 505 #endif
 506
 507         /* ensure the host is in compatible mode */
 508         ppbus_1284_terminate(dev);
 509
 510         /* reset error to catch the actual negotiation error */
 511         ppbus_1284_reset_error(bus, PPBUS_FORWARD_IDLE);
 512
 513         /* calculate ext. value */
 514         request_mode = ppbus_request_mode(mode, options);
 515
 516         /* default state */
 517         ppbus_wctr(dev, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED));
 518         DELAY(1);
 519
 520         /* enter negotiation phase */
 521         ppbus_1284_set_state(dev, PPBUS_NEGOTIATION);
 522
 523         /* Event 0 - put the exten. value on the data lines */
 524         ppbus_wdtr(dev, request_mode);
 525
 526 #ifdef PERIPH_1284
 527         /* request remote host attention */
 528         ppbus_wctr(dev, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN));
 529         DELAY(1);
 530         ppbus_wctr(dev, (nINIT) & ~(STROBE | AUTOFEED | SELECTIN));
 531 #else
 532         DELAY(1);
 533
 534 #endif /* !PERIPH_1284 */
 535
 536         /* Event 1 - enter IEEE1284 mode */
 537         ppbus_wctr(dev, (nINIT | AUTOFEED) & ~(STROBE | SELECTIN));
 538
 539 #ifdef PERIPH_1284
 540         /* ignore the PError line, wait a bit more, remote host's
 541          * interrupts don't respond fast enough */
 542         if (ppbus_poll_bus(bus, 40, nACK | SELECT | nFAULT,
 543                                 SELECT | nFAULT, PPBUS_NOINTR | PPBUS_POLL)) {
 544                 ppbus_1284_set_error(bus, PPBUS_NOT_IEEE1284, 2);
 545                 error = ENODEV;
 546                 goto error;
 547         }
 548 #else
 549         /* Event 2 - trying IEEE1284 dialog */
 550         if (do_1284_wait(bus, nACK | PERROR | SELECT | nFAULT,
 551                         PERROR  | SELECT | nFAULT)) {
 552                 ppbus_1284_set_error(bus, PPBUS_NOT_IEEE1284, 2);
 553                 error = ENODEV;
 554                 goto error;
 555         }
 556 #endif /* !PERIPH_1284 */
 557
 558         /* Event 3 - latch the ext. value to the peripheral */
 559         ppbus_wctr(dev, (nINIT | STROBE | AUTOFEED) & ~SELECTIN);
 560         DELAY(1);
 561
 562         /* Event 4 - IEEE1284 device recognized */
 563         ppbus_wctr(dev, nINIT & ~(SELECTIN | AUTOFEED | STROBE));
 564
 565         /* Event 6 - waiting for status lines */
 566         if (do_1284_wait(bus, nACK, nACK)) {
 567                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 6);
 568                 error = EBUSY;
 569                 goto error;
 570         }
 571
 572         /* Event 7 - quering result consider nACK not to misunderstand
 573          * a remote computer terminate sequence */
 574         if (options & PPBUS_EXTENSIBILITY_LINK) {
 575                 /* XXX not fully supported yet */
 576                 ppbus_1284_terminate(dev);
 577                 error = ENODEV;
 578                 goto error;
 579                 /* return (0); */
 580         }
 581         if (request_mode == NIBBLE_1284_NORMAL) {
 582                 if (do_1284_wait(bus, nACK | SELECT, nACK)) {
 583                         ppbus_1284_set_error(bus, PPBUS_MODE_UNSUPPORTED, 7);
 584                         error = ENODEV;
 585                         goto error;
 586                 }
 587         } else {
 588                 if (do_1284_wait(bus, nACK | SELECT, SELECT | nACK)) {
 589                         ppbus_1284_set_error(bus, PPBUS_MODE_UNSUPPORTED, 7);
 590                         error = ENODEV;
 591                         goto error;
 592                 }
 593         }
 594
 595         switch (mode) {
 596         case PPBUS_NIBBLE:
 597         case PPBUS_PS2:
 598                 /* enter reverse idle phase */
 599                 ppbus_1284_set_state(dev, PPBUS_REVERSE_IDLE);
 600                 break;
 601         case PPBUS_ECP:
 602                 /* negotiation ok, now setup the communication */
 603                 ppbus_1284_set_state(dev, PPBUS_SETUP);
 604                 ppbus_wctr(dev, (nINIT | AUTOFEED) & ~(SELECTIN | STROBE));
 605
 606 #ifdef PERIPH_1284
 607                 /* ignore PError line */
 608                 if (do_1284_wait(bus, nACK | SELECT | nBUSY,
 609                                         nACK | SELECT | nBUSY)) {
 610                         ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 30);
 611                         error = ENODEV;
 612                         goto error;
 613                 }
 614 #else
 615                 if (do_1284_wait(bus, nACK | SELECT | PERROR | nBUSY,
 616                                         nACK | SELECT | PERROR | nBUSY)) {
 617                         ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 30);
 618                         error = ENODEV;
 619                         goto error;
 620                 }
 621 #endif /* !PERIPH_1284 */
 622
 623                 /* ok, the host enters the ForwardIdle state */
 624                 ppbus_1284_set_state(dev, PPBUS_ECP_FORWARD_IDLE);
 625                 break;
 626         case PPBUS_EPP:
 627                 ppbus_1284_set_state(dev, PPBUS_EPP_IDLE);
 628                 break;
 629         default:
 630                 panic("%s: unknown mode (%d)!", __func__, mode);
 631         }
 632
 633         return 0;
 634
 635 error:
 636         ppbus_1284_terminate(dev);
 637         return error;
 638 }
 639
 640 /*
 641  * IEEE1284 termination phase, return code should ignored since the host
 642  * is _always_ in compatible mode after ppbus_1284_terminate()
 643  */
 644 int
 645 ppbus_1284_terminate(device_t dev)
 646 {
 647         struct ppbus_softc * bus = device_private(dev);
 648
 649 #ifdef DEBUG_1284
 650         printf("T");
 651 #endif
 652
 653         /* do not reset error here to keep the error that
 654          * may occurred before the ppbus_1284_terminate() call */
 655         ppbus_1284_set_state(dev, PPBUS_TERMINATION);
 656
 657 #ifdef PERIPH_1284
 658         /* request remote host attention */
 659         ppbus_wctr(dev, (nINIT | STROBE | SELECTIN) & ~(AUTOFEED));
 660         DELAY(1);
 661 #endif /* PERIPH_1284 */
 662
 663         /* Event 22 - set nSelectin low and nAutoFeed high */
 664         ppbus_wctr(dev, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED));
 665
 666         /* Event 24 - waiting for peripheral, Xflag ignored */
 667         if (do_1284_wait(bus, nACK | nBUSY | nFAULT, nFAULT)) {
 668                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 24);
 669                 goto error;
 670         }
 671
 672         /* Event 25 - set nAutoFd low */
 673         ppbus_wctr(dev, (nINIT | SELECTIN | AUTOFEED) & ~STROBE);
 674
 675         /* Event 26 - compatible mode status is set */
 676
 677         /* Event 27 - peripheral set nAck high */
 678         if (do_1284_wait(bus, nACK, nACK)) {
 679                 ppbus_1284_set_error(bus, PPBUS_TIMEOUT, 27);
 680         }
 681
 682         /* Event 28 - end termination, return to idle phase */
 683         ppbus_wctr(dev, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED));
 684
 685 error:
 686         ppbus_1284_set_state(dev, PPBUS_FORWARD_IDLE);
 687
 688         return (0);
 689 }