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