1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 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 * 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 /* 35 * General purpose routines for the IEEE1284-1994 Standard 36 */ 37 38 #include "opt_ppb_1284.h" 39 40 #include <sys/param.h> 41 #include <sys/lock.h> 42 #include <sys/mutex.h> 43 #include <sys/systm.h> 44 #include <sys/bus.h> 45 46 #include <dev/ppbus/ppbconf.h> 47 #include <dev/ppbus/ppb_1284.h> 48 49 #include "ppbus_if.h" 50 51 #include <dev/ppbus/ppbio.h> 52 53 #define DEVTOSOFTC(dev) ((struct ppb_data *)device_get_softc(dev)) 54 55 /* 56 * do_1284_wait() 57 * 58 * Wait for the peripherial up to 40ms 59 */ 60 static int 61 do_1284_wait(device_t bus, uint8_t mask, uint8_t status) 62 { 63 return (ppb_poll_bus(bus, 4, mask, status, PPB_NOINTR | PPB_POLL)); 64 } 65 66 static int 67 do_peripheral_wait(device_t bus, uint8_t mask, uint8_t status) 68 { 69 return (ppb_poll_bus(bus, 100, mask, status, PPB_NOINTR | PPB_POLL)); 70 } 71 72 #define nibble2char(s) (((s & ~nACK) >> 3) | (~s & nBUSY) >> 4) 73 74 /* 75 * ppb_1284_reset_error() 76 * 77 * Unconditionaly reset the error field 78 */ 79 static int 80 ppb_1284_reset_error(device_t bus, int state) 81 { 82 struct ppb_data *ppb = DEVTOSOFTC(bus); 83 84 ppb->error = PPB_NO_ERROR; 85 ppb->state = state; 86 87 return (0); 88 } 89 90 /* 91 * ppb_1284_get_state() 92 * 93 * Get IEEE1284 state 94 */ 95 int 96 ppb_1284_get_state(device_t bus) 97 { 98 struct ppb_data *ppb = DEVTOSOFTC(bus); 99 100 mtx_assert(ppb->ppc_lock, MA_OWNED); 101 return (ppb->state); 102 } 103 104 /* 105 * ppb_1284_set_state() 106 * 107 * Change IEEE1284 state if no error occurred 108 */ 109 int 110 ppb_1284_set_state(device_t bus, int state) 111 { 112 struct ppb_data *ppb = DEVTOSOFTC(bus); 113 114 /* call ppb_1284_reset_error() if you absolutely want to change 115 * the state from PPB_ERROR to another */ 116 mtx_assert(ppb->ppc_lock, MA_OWNED); 117 if ((ppb->state != PPB_ERROR) && 118 (ppb->error == PPB_NO_ERROR)) { 119 ppb->state = state; 120 ppb->error = PPB_NO_ERROR; 121 } 122 123 return (0); 124 } 125 126 static int 127 ppb_1284_set_error(device_t bus, int error, int event) 128 { 129 struct ppb_data *ppb = DEVTOSOFTC(bus); 130 131 /* do not accumulate errors */ 132 if ((ppb->error == PPB_NO_ERROR) && 133 (ppb->state != PPB_ERROR)) { 134 ppb->error = error; 135 ppb->state = PPB_ERROR; 136 } 137 138 #ifdef DEBUG_1284 139 printf("ppb1284: error=%d status=0x%x event=%d\n", error, 140 ppb_rstr(bus) & 0xff, event); 141 #endif 142 143 return (0); 144 } 145 146 /* 147 * ppb_request_mode() 148 * 149 * Converts mode+options into ext. value 150 */ 151 static int 152 ppb_request_mode(int mode, int options) 153 { 154 int request_mode = 0; 155 156 if (options & PPB_EXTENSIBILITY_LINK) { 157 request_mode = EXT_LINK_1284_NORMAL; 158 159 } else { 160 switch (mode) { 161 case PPB_NIBBLE: 162 request_mode = (options & PPB_REQUEST_ID) ? 163 NIBBLE_1284_REQUEST_ID : 164 NIBBLE_1284_NORMAL; 165 break; 166 case PPB_PS2: 167 request_mode = (options & PPB_REQUEST_ID) ? 168 BYTE_1284_REQUEST_ID : 169 BYTE_1284_NORMAL; 170 break; 171 case PPB_ECP: 172 if (options & PPB_USE_RLE) 173 request_mode = (options & PPB_REQUEST_ID) ? 174 ECP_1284_RLE_REQUEST_ID : 175 ECP_1284_RLE; 176 else 177 request_mode = (options & PPB_REQUEST_ID) ? 178 ECP_1284_REQUEST_ID : 179 ECP_1284_NORMAL; 180 break; 181 case PPB_EPP: 182 request_mode = EPP_1284_NORMAL; 183 break; 184 default: 185 panic("%s: unsupported mode %d\n", __func__, mode); 186 } 187 } 188 189 return (request_mode); 190 } 191 192 /* 193 * ppb_peripheral_negociate() 194 * 195 * Negotiate the peripheral side 196 */ 197 int 198 ppb_peripheral_negociate(device_t bus, int mode, int options) 199 { 200 int spin, request_mode, error = 0; 201 char r; 202 203 ppb_set_mode(bus, PPB_COMPATIBLE); 204 ppb_1284_set_state(bus, PPB_PERIPHERAL_NEGOCIATION); 205 206 /* compute ext. value */ 207 request_mode = ppb_request_mode(mode, options); 208 209 /* wait host */ 210 spin = 10; 211 while (spin-- && (ppb_rstr(bus) & nBUSY)) 212 DELAY(1); 213 214 /* check termination */ 215 if (!(ppb_rstr(bus) & SELECT) || !spin) { 216 error = ENODEV; 217 goto error; 218 } 219 220 /* Event 4 - read ext. value */ 221 r = ppb_rdtr(bus); 222 223 /* nibble mode is not supported */ 224 if ((r == (char)request_mode) || 225 (r == NIBBLE_1284_NORMAL)) { 226 /* Event 5 - restore direction bit, no data avail */ 227 ppb_wctr(bus, (STROBE | nINIT) & ~(SELECTIN)); 228 DELAY(1); 229 230 /* Event 6 */ 231 ppb_wctr(bus, (nINIT) & ~(SELECTIN | STROBE)); 232 233 if (r == NIBBLE_1284_NORMAL) { 234 #ifdef DEBUG_1284 235 printf("R"); 236 #endif 237 ppb_1284_set_error(bus, PPB_MODE_UNSUPPORTED, 4); 238 error = EINVAL; 239 goto error; 240 } else { 241 ppb_1284_set_state(bus, PPB_PERIPHERAL_IDLE); 242 switch (r) { 243 case BYTE_1284_NORMAL: 244 ppb_set_mode(bus, PPB_BYTE); 245 break; 246 default: 247 break; 248 } 249 #ifdef DEBUG_1284 250 printf("A"); 251 #endif 252 /* negotiation succeeds */ 253 } 254 } else { 255 /* Event 5 - mode not supported */ 256 ppb_wctr(bus, SELECTIN); 257 DELAY(1); 258 259 /* Event 6 */ 260 ppb_wctr(bus, (SELECTIN) & ~(STROBE | nINIT)); 261 ppb_1284_set_error(bus, PPB_MODE_UNSUPPORTED, 4); 262 263 #ifdef DEBUG_1284 264 printf("r"); 265 #endif 266 error = EINVAL; 267 goto error; 268 } 269 270 return (0); 271 272 error: 273 ppb_peripheral_terminate(bus, PPB_WAIT); 274 return (error); 275 } 276 277 /* 278 * ppb_peripheral_terminate() 279 * 280 * Terminate peripheral transfer side 281 * 282 * Always return 0 in compatible mode 283 */ 284 int 285 ppb_peripheral_terminate(device_t bus, int how) 286 { 287 int error = 0; 288 289 #ifdef DEBUG_1284 290 printf("t"); 291 #endif 292 293 ppb_1284_set_state(bus, PPB_PERIPHERAL_TERMINATION); 294 295 /* Event 22 - wait up to host response time (1s) */ 296 if ((error = do_peripheral_wait(bus, SELECT | nBUSY, 0))) { 297 ppb_1284_set_error(bus, PPB_TIMEOUT, 22); 298 goto error; 299 } 300 301 /* Event 24 */ 302 ppb_wctr(bus, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); 303 304 /* Event 25 - wait up to host response time (1s) */ 305 if ((error = do_peripheral_wait(bus, nBUSY, nBUSY))) { 306 ppb_1284_set_error(bus, PPB_TIMEOUT, 25); 307 goto error; 308 } 309 310 /* Event 26 */ 311 ppb_wctr(bus, (SELECTIN | nINIT | STROBE) & ~(AUTOFEED)); 312 DELAY(1); 313 /* Event 27 */ 314 ppb_wctr(bus, (SELECTIN | nINIT) & ~(STROBE | AUTOFEED)); 315 316 /* Event 28 - wait up to host response time (1s) */ 317 if ((error = do_peripheral_wait(bus, nBUSY, 0))) { 318 ppb_1284_set_error(bus, PPB_TIMEOUT, 28); 319 goto error; 320 } 321 322 error: 323 ppb_set_mode(bus, PPB_COMPATIBLE); 324 ppb_1284_set_state(bus, PPB_FORWARD_IDLE); 325 326 return (0); 327 } 328 329 /* 330 * byte_peripheral_outbyte() 331 * 332 * Write 1 byte in BYTE mode 333 */ 334 static int 335 byte_peripheral_outbyte(device_t bus, char *buffer, int last) 336 { 337 int error = 0; 338 339 /* Event 7 */ 340 if ((error = do_1284_wait(bus, nBUSY, nBUSY))) { 341 ppb_1284_set_error(bus, PPB_TIMEOUT, 7); 342 goto error; 343 } 344 345 /* check termination */ 346 if (!(ppb_rstr(bus) & SELECT)) { 347 ppb_peripheral_terminate(bus, PPB_WAIT); 348 goto error; 349 } 350 351 /* Event 15 - put byte on data lines */ 352 #ifdef DEBUG_1284 353 printf("B"); 354 #endif 355 ppb_wdtr(bus, *buffer); 356 357 /* Event 9 */ 358 ppb_wctr(bus, (AUTOFEED | STROBE) & ~(nINIT | SELECTIN)); 359 360 /* Event 10 - wait data read */ 361 if ((error = do_peripheral_wait(bus, nBUSY, 0))) { 362 ppb_1284_set_error(bus, PPB_TIMEOUT, 16); 363 goto error; 364 } 365 366 /* Event 11 */ 367 if (!last) { 368 ppb_wctr(bus, (AUTOFEED) & ~(nINIT | STROBE | SELECTIN)); 369 } else { 370 ppb_wctr(bus, (nINIT) & ~(STROBE | SELECTIN | AUTOFEED)); 371 } 372 373 #if 0 374 /* Event 16 - wait strobe */ 375 if ((error = do_peripheral_wait(bus, nACK | nBUSY, 0))) { 376 ppb_1284_set_error(bus, PPB_TIMEOUT, 16); 377 goto error; 378 } 379 #endif 380 381 /* check termination */ 382 if (!(ppb_rstr(bus) & SELECT)) { 383 ppb_peripheral_terminate(bus, PPB_WAIT); 384 goto error; 385 } 386 387 error: 388 return (error); 389 } 390 391 /* 392 * byte_peripheral_write() 393 * 394 * Write n bytes in BYTE mode 395 */ 396 int 397 byte_peripheral_write(device_t bus, char *buffer, int len, int *sent) 398 { 399 int error = 0, i; 400 char r; 401 402 ppb_1284_set_state(bus, PPB_PERIPHERAL_TRANSFER); 403 404 /* wait forever, the remote host is master and should initiate 405 * termination 406 */ 407 for (i=0; i<len; i++) { 408 /* force remote nFAULT low to release the remote waiting 409 * process, if any 410 */ 411 r = ppb_rctr(bus); 412 ppb_wctr(bus, r & ~nINIT); 413 414 #ifdef DEBUG_1284 415 printf("y"); 416 #endif 417 /* Event 7 */ 418 error = ppb_poll_bus(bus, PPB_FOREVER, nBUSY, nBUSY, 419 PPB_INTR); 420 421 if (error && error != EWOULDBLOCK) 422 goto error; 423 424 #ifdef DEBUG_1284 425 printf("b"); 426 #endif 427 if ((error = byte_peripheral_outbyte(bus, buffer+i, (i == len-1)))) 428 goto error; 429 } 430 error: 431 if (!error) 432 ppb_1284_set_state(bus, PPB_PERIPHERAL_IDLE); 433 434 *sent = i; 435 return (error); 436 } 437 438 /* 439 * byte_1284_inbyte() 440 * 441 * Read 1 byte in BYTE mode 442 */ 443 int 444 byte_1284_inbyte(device_t bus, char *buffer) 445 { 446 int error = 0; 447 448 /* Event 7 - ready to take data (nAUTO low) */ 449 ppb_wctr(bus, (PCD | nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); 450 451 /* Event 9 - peripheral set nAck low */ 452 if ((error = do_1284_wait(bus, nACK, 0))) { 453 ppb_1284_set_error(bus, PPB_TIMEOUT, 9); 454 goto error; 455 } 456 457 /* read the byte */ 458 *buffer = ppb_rdtr(bus); 459 460 /* Event 10 - data received, can't accept more */ 461 ppb_wctr(bus, (nINIT) & ~(AUTOFEED | STROBE | SELECTIN)); 462 463 /* Event 11 - peripheral ack */ 464 if ((error = do_1284_wait(bus, nACK, nACK))) { 465 ppb_1284_set_error(bus, PPB_TIMEOUT, 11); 466 goto error; 467 } 468 469 /* Event 16 - strobe */ 470 ppb_wctr(bus, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); 471 DELAY(3); 472 ppb_wctr(bus, (nINIT) & ~(AUTOFEED | STROBE | SELECTIN)); 473 474 error: 475 return (error); 476 } 477 478 /* 479 * nibble_1284_inbyte() 480 * 481 * Read 1 byte in NIBBLE mode 482 */ 483 int 484 nibble_1284_inbyte(device_t bus, char *buffer) 485 { 486 char nibble[2]; 487 int i, error; 488 489 for (i = 0; i < 2; i++) { 490 /* Event 7 - ready to take data (nAUTO low) */ 491 ppb_wctr(bus, (nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); 492 493 /* Event 8 - peripheral writes the first nibble */ 494 495 /* Event 9 - peripheral set nAck low */ 496 if ((error = do_1284_wait(bus, nACK, 0))) { 497 ppb_1284_set_error(bus, PPB_TIMEOUT, 9); 498 goto error; 499 } 500 501 /* read nibble */ 502 nibble[i] = ppb_rstr(bus); 503 504 /* Event 10 - ack, nibble received */ 505 ppb_wctr(bus, nINIT & ~(AUTOFEED | STROBE | SELECTIN)); 506 507 /* Event 11 - wait ack from peripherial */ 508 if ((error = do_1284_wait(bus, nACK, nACK))) { 509 ppb_1284_set_error(bus, PPB_TIMEOUT, 11); 510 goto error; 511 } 512 } 513 514 *buffer = ((nibble2char(nibble[1]) << 4) & 0xf0) | 515 (nibble2char(nibble[0]) & 0x0f); 516 517 error: 518 return (error); 519 } 520 521 /* 522 * spp_1284_read() 523 * 524 * Read in IEEE1284 NIBBLE/BYTE mode 525 */ 526 int 527 spp_1284_read(device_t bus, int mode, char *buffer, int max, int *read) 528 { 529 int error = 0, len = 0; 530 int terminate_after_transfer = 1; 531 int state; 532 533 *read = len = 0; 534 535 state = ppb_1284_get_state(bus); 536 537 switch (state) { 538 case PPB_FORWARD_IDLE: 539 if ((error = ppb_1284_negociate(bus, mode, 0))) 540 return (error); 541 break; 542 543 case PPB_REVERSE_IDLE: 544 terminate_after_transfer = 0; 545 break; 546 547 default: 548 ppb_1284_terminate(bus); 549 if ((error = ppb_1284_negociate(bus, mode, 0))) 550 return (error); 551 break; 552 } 553 554 while ((len < max) && !(ppb_rstr(bus) & (nFAULT))) { 555 ppb_1284_set_state(bus, PPB_REVERSE_TRANSFER); 556 557 #ifdef DEBUG_1284 558 printf("B"); 559 #endif 560 561 switch (mode) { 562 case PPB_NIBBLE: 563 /* read a byte, error means no more data */ 564 if (nibble_1284_inbyte(bus, buffer+len)) 565 goto end_while; 566 break; 567 case PPB_BYTE: 568 if (byte_1284_inbyte(bus, buffer+len)) 569 goto end_while; 570 break; 571 default: 572 error = EINVAL; 573 goto end_while; 574 } 575 len ++; 576 } 577 end_while: 578 579 if (!error) 580 ppb_1284_set_state(bus, PPB_REVERSE_IDLE); 581 582 *read = len; 583 584 if (terminate_after_transfer || error) 585 ppb_1284_terminate(bus); 586 587 return (error); 588 } 589 590 /* 591 * ppb_1284_read_id() 592 * 593 */ 594 int 595 ppb_1284_read_id(device_t bus, int mode, char *buffer, 596 int max, int *read) 597 { 598 int error = 0; 599 600 /* fill the buffer with 0s */ 601 bzero(buffer, max); 602 603 switch (mode) { 604 case PPB_NIBBLE: 605 case PPB_ECP: 606 if ((error = ppb_1284_negociate(bus, PPB_NIBBLE, PPB_REQUEST_ID))) 607 return (error); 608 error = spp_1284_read(bus, PPB_NIBBLE, buffer, max, read); 609 break; 610 case PPB_BYTE: 611 if ((error = ppb_1284_negociate(bus, PPB_BYTE, PPB_REQUEST_ID))) 612 return (error); 613 error = spp_1284_read(bus, PPB_BYTE, buffer, max, read); 614 break; 615 default: 616 panic("%s: unsupported mode %d\n", __func__, mode); 617 } 618 619 ppb_1284_terminate(bus); 620 return (error); 621 } 622 623 /* 624 * ppb_1284_read() 625 * 626 * IEEE1284 read 627 */ 628 int 629 ppb_1284_read(device_t bus, int mode, char *buffer, 630 int max, int *read) 631 { 632 int error = 0; 633 634 switch (mode) { 635 case PPB_NIBBLE: 636 case PPB_BYTE: 637 error = spp_1284_read(bus, mode, buffer, max, read); 638 break; 639 default: 640 return (EINVAL); 641 } 642 643 return (error); 644 } 645 646 /* 647 * ppb_1284_negociate() 648 * 649 * IEEE1284 negotiation phase 650 * 651 * Normal nibble mode or request device id mode (see ppb_1284.h) 652 * 653 * After negotiation, nFAULT is low if data is available 654 */ 655 int 656 ppb_1284_negociate(device_t bus, int mode, int options) 657 { 658 int error; 659 int request_mode; 660 661 #ifdef DEBUG_1284 662 printf("n"); 663 #endif 664 665 if (ppb_1284_get_state(bus) >= PPB_PERIPHERAL_NEGOCIATION) 666 ppb_peripheral_terminate(bus, PPB_WAIT); 667 668 if (ppb_1284_get_state(bus) != PPB_FORWARD_IDLE) 669 ppb_1284_terminate(bus); 670 671 #ifdef DEBUG_1284 672 printf("%d", mode); 673 #endif 674 675 /* ensure the host is in compatible mode */ 676 ppb_set_mode(bus, PPB_COMPATIBLE); 677 678 /* reset error to catch the actual negotiation error */ 679 ppb_1284_reset_error(bus, PPB_FORWARD_IDLE); 680 681 /* calculate ext. value */ 682 request_mode = ppb_request_mode(mode, options); 683 684 /* default state */ 685 ppb_wctr(bus, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); 686 DELAY(1); 687 688 /* enter negotiation phase */ 689 ppb_1284_set_state(bus, PPB_NEGOCIATION); 690 691 /* Event 0 - put the exten. value on the data lines */ 692 ppb_wdtr(bus, request_mode); 693 694 #ifdef PERIPH_1284 695 /* request remote host attention */ 696 ppb_wctr(bus, (nINIT | STROBE) & ~(AUTOFEED | SELECTIN)); 697 DELAY(1); 698 ppb_wctr(bus, (nINIT) & ~(STROBE | AUTOFEED | SELECTIN)); 699 #else 700 DELAY(1); 701 702 #endif /* !PERIPH_1284 */ 703 704 /* Event 1 - enter IEEE1284 mode */ 705 ppb_wctr(bus, (nINIT | AUTOFEED) & ~(STROBE | SELECTIN)); 706 707 #ifdef PERIPH_1284 708 /* ignore the PError line, wait a bit more, remote host's 709 * interrupts don't respond fast enough */ 710 if (ppb_poll_bus(bus, 40, nACK | SELECT | nFAULT, 711 SELECT | nFAULT, PPB_NOINTR | PPB_POLL)) { 712 ppb_1284_set_error(bus, PPB_NOT_IEEE1284, 2); 713 error = ENODEV; 714 goto error; 715 } 716 #else 717 /* Event 2 - trying IEEE1284 dialog */ 718 if (do_1284_wait(bus, nACK | PERROR | SELECT | nFAULT, 719 PERROR | SELECT | nFAULT)) { 720 ppb_1284_set_error(bus, PPB_NOT_IEEE1284, 2); 721 error = ENODEV; 722 goto error; 723 } 724 #endif /* !PERIPH_1284 */ 725 726 /* Event 3 - latch the ext. value to the peripheral */ 727 ppb_wctr(bus, (nINIT | STROBE | AUTOFEED) & ~SELECTIN); 728 DELAY(1); 729 730 /* Event 4 - IEEE1284 device recognized */ 731 ppb_wctr(bus, nINIT & ~(SELECTIN | AUTOFEED | STROBE)); 732 733 /* Event 6 - waiting for status lines */ 734 if (do_1284_wait(bus, nACK, nACK)) { 735 ppb_1284_set_error(bus, PPB_TIMEOUT, 6); 736 error = EBUSY; 737 goto error; 738 } 739 740 /* Event 7 - querying result consider nACK not to misunderstand 741 * a remote computer terminate sequence */ 742 if (options & PPB_EXTENSIBILITY_LINK) { 743 /* XXX not fully supported yet */ 744 ppb_1284_terminate(bus); 745 return (0); 746 } 747 if (request_mode == NIBBLE_1284_NORMAL) { 748 if (do_1284_wait(bus, nACK | SELECT, nACK)) { 749 ppb_1284_set_error(bus, PPB_MODE_UNSUPPORTED, 7); 750 error = ENODEV; 751 goto error; 752 } 753 } else { 754 if (do_1284_wait(bus, nACK | SELECT, SELECT | nACK)) { 755 ppb_1284_set_error(bus, PPB_MODE_UNSUPPORTED, 7); 756 error = ENODEV; 757 goto error; 758 } 759 } 760 761 switch (mode) { 762 case PPB_NIBBLE: 763 case PPB_PS2: 764 /* enter reverse idle phase */ 765 ppb_1284_set_state(bus, PPB_REVERSE_IDLE); 766 break; 767 case PPB_ECP: 768 /* negotiation ok, now setup the communication */ 769 ppb_1284_set_state(bus, PPB_SETUP); 770 ppb_wctr(bus, (nINIT | AUTOFEED) & ~(SELECTIN | STROBE)); 771 772 #ifdef PERIPH_1284 773 /* ignore PError line */ 774 if (do_1284_wait(bus, nACK | SELECT | nBUSY, 775 nACK | SELECT | nBUSY)) { 776 ppb_1284_set_error(bus, PPB_TIMEOUT, 30); 777 error = ENODEV; 778 goto error; 779 } 780 #else 781 if (do_1284_wait(bus, nACK | SELECT | PERROR | nBUSY, 782 nACK | SELECT | PERROR | nBUSY)) { 783 ppb_1284_set_error(bus, PPB_TIMEOUT, 30); 784 error = ENODEV; 785 goto error; 786 } 787 #endif /* !PERIPH_1284 */ 788 789 /* ok, the host enters the ForwardIdle state */ 790 ppb_1284_set_state(bus, PPB_ECP_FORWARD_IDLE); 791 break; 792 case PPB_EPP: 793 ppb_1284_set_state(bus, PPB_EPP_IDLE); 794 break; 795 796 default: 797 panic("%s: unknown mode (%d)!", __func__, mode); 798 } 799 ppb_set_mode(bus, mode); 800 801 return (0); 802 803 error: 804 ppb_1284_terminate(bus); 805 806 return (error); 807 } 808 809 /* 810 * ppb_1284_terminate() 811 * 812 * IEEE1284 termination phase, return code should ignored since the host 813 * is _always_ in compatible mode after ppb_1284_terminate() 814 */ 815 int 816 ppb_1284_terminate(device_t bus) 817 { 818 819 #ifdef DEBUG_1284 820 printf("T"); 821 #endif 822 823 /* do not reset error here to keep the error that 824 * may occurred before the ppb_1284_terminate() call */ 825 ppb_1284_set_state(bus, PPB_TERMINATION); 826 827 #ifdef PERIPH_1284 828 /* request remote host attention */ 829 ppb_wctr(bus, (nINIT | STROBE | SELECTIN) & ~(AUTOFEED)); 830 DELAY(1); 831 #endif /* PERIPH_1284 */ 832 833 /* Event 22 - set nSelectin low and nAutoFeed high */ 834 ppb_wctr(bus, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); 835 836 /* Event 24 - waiting for peripheral, Xflag ignored */ 837 if (do_1284_wait(bus, nACK | nBUSY | nFAULT, nFAULT)) { 838 ppb_1284_set_error(bus, PPB_TIMEOUT, 24); 839 goto error; 840 } 841 842 /* Event 25 - set nAutoFd low */ 843 ppb_wctr(bus, (nINIT | SELECTIN | AUTOFEED) & ~STROBE); 844 845 /* Event 26 - compatible mode status is set */ 846 847 /* Event 27 - peripheral set nAck high */ 848 if (do_1284_wait(bus, nACK, nACK)) { 849 ppb_1284_set_error(bus, PPB_TIMEOUT, 27); 850 } 851 852 /* Event 28 - end termination, return to idle phase */ 853 ppb_wctr(bus, (nINIT | SELECTIN) & ~(STROBE | AUTOFEED)); 854 855 error: 856 /* return to compatible mode */ 857 ppb_set_mode(bus, PPB_COMPATIBLE); 858 ppb_1284_set_state(bus, PPB_FORWARD_IDLE); 859 860 return (0); 861 } 862