1 /************************************************************************** 2 ** 3 ** $FreeBSD: src/sys/pci/ncr.c,v 1.155.2.3 2001/03/05 13:09:10 obrien Exp $ 4 ** $DragonFly: src/sys/dev/disk/ncr/ncr.c,v 1.4 2003/08/07 21:16:53 dillon Exp $ 5 ** 6 ** Device driver for the NCR 53C8XX PCI-SCSI-Controller Family. 7 ** 8 **------------------------------------------------------------------------- 9 ** 10 ** Written for 386bsd and FreeBSD by 11 ** Wolfgang Stanglmeier <wolf@cologne.de> 12 ** Stefan Esser <se@mi.Uni-Koeln.de> 13 ** 14 **------------------------------------------------------------------------- 15 ** 16 ** Copyright (c) 1994 Wolfgang Stanglmeier. All rights reserved. 17 ** 18 ** Redistribution and use in source and binary forms, with or without 19 ** modification, are permitted provided that the following conditions 20 ** are met: 21 ** 1. Redistributions of source code must retain the above copyright 22 ** notice, this list of conditions and the following disclaimer. 23 ** 2. Redistributions in binary form must reproduce the above copyright 24 ** notice, this list of conditions and the following disclaimer in the 25 ** documentation and/or other materials provided with the distribution. 26 ** 3. The name of the author may not be used to endorse or promote products 27 ** derived from this software without specific prior written permission. 28 ** 29 ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 30 ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 31 ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 32 ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 33 ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 34 ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 35 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 36 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 37 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 38 ** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 39 ** 40 *************************************************************************** 41 */ 42 43 #define NCR_DATE "pl30 98/1/1" 44 45 #define NCR_VERSION (2) 46 #define MAX_UNITS (16) 47 48 #define NCR_GETCC_WITHMSG 49 50 #if defined (__FreeBSD__) && defined(_KERNEL) 51 #include "opt_ncr.h" 52 #endif 53 54 /*========================================================== 55 ** 56 ** Configuration and Debugging 57 ** 58 ** May be overwritten in <arch/conf/xxxx> 59 ** 60 **========================================================== 61 */ 62 63 /* 64 ** SCSI address of this device. 65 ** The boot routines should have set it. 66 ** If not, use this. 67 */ 68 69 #ifndef SCSI_NCR_MYADDR 70 #define SCSI_NCR_MYADDR (7) 71 #endif /* SCSI_NCR_MYADDR */ 72 73 /* 74 ** The default synchronous period factor 75 ** (0=asynchronous) 76 ** If maximum synchronous frequency is defined, use it instead. 77 */ 78 79 #ifndef SCSI_NCR_MAX_SYNC 80 81 #ifndef SCSI_NCR_DFLT_SYNC 82 #define SCSI_NCR_DFLT_SYNC (12) 83 #endif /* SCSI_NCR_DFLT_SYNC */ 84 85 #else 86 87 #if SCSI_NCR_MAX_SYNC == 0 88 #define SCSI_NCR_DFLT_SYNC 0 89 #else 90 #define SCSI_NCR_DFLT_SYNC (250000 / SCSI_NCR_MAX_SYNC) 91 #endif 92 93 #endif 94 95 /* 96 ** The minimal asynchronous pre-scaler period (ns) 97 ** Shall be 40. 98 */ 99 100 #ifndef SCSI_NCR_MIN_ASYNC 101 #define SCSI_NCR_MIN_ASYNC (40) 102 #endif /* SCSI_NCR_MIN_ASYNC */ 103 104 /* 105 ** The maximal bus with (in log2 byte) 106 ** (0=8 bit, 1=16 bit) 107 */ 108 109 #ifndef SCSI_NCR_MAX_WIDE 110 #define SCSI_NCR_MAX_WIDE (1) 111 #endif /* SCSI_NCR_MAX_WIDE */ 112 113 /*========================================================== 114 ** 115 ** Configuration and Debugging 116 ** 117 **========================================================== 118 */ 119 120 /* 121 ** Number of targets supported by the driver. 122 ** n permits target numbers 0..n-1. 123 ** Default is 7, meaning targets #0..#6. 124 ** #7 .. is myself. 125 */ 126 127 #define MAX_TARGET (16) 128 129 /* 130 ** Number of logic units supported by the driver. 131 ** n enables logic unit numbers 0..n-1. 132 ** The common SCSI devices require only 133 ** one lun, so take 1 as the default. 134 */ 135 136 #ifndef MAX_LUN 137 #define MAX_LUN (8) 138 #endif /* MAX_LUN */ 139 140 /* 141 ** The maximum number of jobs scheduled for starting. 142 ** There should be one slot per target, and one slot 143 ** for each tag of each target in use. 144 */ 145 146 #define MAX_START (256) 147 148 /* 149 ** The maximum number of segments a transfer is split into. 150 */ 151 152 #define MAX_SCATTER (33) 153 154 /* 155 ** The maximum transfer length (should be >= 64k). 156 ** MUST NOT be greater than (MAX_SCATTER-1) * PAGE_SIZE. 157 */ 158 159 #define MAX_SIZE ((MAX_SCATTER-1) * (long) PAGE_SIZE) 160 161 /* 162 ** other 163 */ 164 165 #define NCR_SNOOP_TIMEOUT (1000000) 166 167 /*========================================================== 168 ** 169 ** Include files 170 ** 171 **========================================================== 172 */ 173 174 #include <sys/param.h> 175 #include <sys/time.h> 176 177 #ifdef _KERNEL 178 #include <sys/systm.h> 179 #include <sys/malloc.h> 180 #include <sys/buf.h> 181 #include <sys/kernel.h> 182 #include <sys/sysctl.h> 183 #include <sys/bus.h> 184 #include <machine/clock.h> 185 #include <machine/md_var.h> 186 #include <machine/bus.h> 187 #include <machine/resource.h> 188 #include <sys/rman.h> 189 #include <vm/vm.h> 190 #include <vm/pmap.h> 191 #include <vm/vm_extern.h> 192 #endif 193 194 #include <bus/pci/pcivar.h> 195 #include <bus/pci/pcireg.h> 196 #include "ncrreg.h" 197 198 #include <bus/cam/cam.h> 199 #include <bus/cam/cam_ccb.h> 200 #include <bus/cam/cam_sim.h> 201 #include <bus/cam/cam_xpt_sim.h> 202 #include <bus/cam/cam_debug.h> 203 204 #include <bus/cam/scsi/scsi_all.h> 205 #include <bus/cam/scsi/scsi_message.h> 206 207 /*========================================================== 208 ** 209 ** Debugging tags 210 ** 211 **========================================================== 212 */ 213 214 #define DEBUG_ALLOC (0x0001) 215 #define DEBUG_PHASE (0x0002) 216 #define DEBUG_POLL (0x0004) 217 #define DEBUG_QUEUE (0x0008) 218 #define DEBUG_RESULT (0x0010) 219 #define DEBUG_SCATTER (0x0020) 220 #define DEBUG_SCRIPT (0x0040) 221 #define DEBUG_TINY (0x0080) 222 #define DEBUG_TIMING (0x0100) 223 #define DEBUG_NEGO (0x0200) 224 #define DEBUG_TAGS (0x0400) 225 #define DEBUG_FREEZE (0x0800) 226 #define DEBUG_RESTART (0x1000) 227 228 /* 229 ** Enable/Disable debug messages. 230 ** Can be changed at runtime too. 231 */ 232 #ifdef SCSI_NCR_DEBUG 233 #define DEBUG_FLAGS ncr_debug 234 #else /* SCSI_NCR_DEBUG */ 235 #define SCSI_NCR_DEBUG 0 236 #define DEBUG_FLAGS 0 237 #endif /* SCSI_NCR_DEBUG */ 238 239 240 241 /*========================================================== 242 ** 243 ** assert () 244 ** 245 **========================================================== 246 ** 247 ** modified copy from 386bsd:/usr/include/sys/assert.h 248 ** 249 **---------------------------------------------------------- 250 */ 251 252 #ifdef DIAGNOSTIC 253 #define assert(expression) { \ 254 if (!(expression)) { \ 255 (void)printf("assertion \"%s\" failed: " \ 256 "file \"%s\", line %d\n", \ 257 #expression, __FILE__, __LINE__); \ 258 Debugger(""); \ 259 } \ 260 } 261 #else 262 #define assert(expression) { \ 263 if (!(expression)) { \ 264 (void)printf("assertion \"%s\" failed: " \ 265 "file \"%s\", line %d\n", \ 266 #expression, __FILE__, __LINE__); \ 267 } \ 268 } 269 #endif 270 271 /*========================================================== 272 ** 273 ** Access to the controller chip. 274 ** 275 **========================================================== 276 */ 277 278 #ifdef __alpha__ 279 /* XXX */ 280 #undef vtophys 281 #define vtophys(va) alpha_XXX_dmamap((vm_offset_t)va) 282 #endif 283 284 #define INB(r) bus_space_read_1(np->bst, np->bsh, offsetof(struct ncr_reg, r)) 285 #define INW(r) bus_space_read_2(np->bst, np->bsh, offsetof(struct ncr_reg, r)) 286 #define INL(r) bus_space_read_4(np->bst, np->bsh, offsetof(struct ncr_reg, r)) 287 288 #define OUTB(r, val) bus_space_write_1(np->bst, np->bsh, \ 289 offsetof(struct ncr_reg, r), val) 290 #define OUTW(r, val) bus_space_write_2(np->bst, np->bsh, \ 291 offsetof(struct ncr_reg, r), val) 292 #define OUTL(r, val) bus_space_write_4(np->bst, np->bsh, \ 293 offsetof(struct ncr_reg, r), val) 294 #define OUTL_OFF(o, val) bus_space_write_4(np->bst, np->bsh, o, val) 295 296 #define INB_OFF(o) bus_space_read_1(np->bst, np->bsh, o) 297 #define INW_OFF(o) bus_space_read_2(np->bst, np->bsh, o) 298 #define INL_OFF(o) bus_space_read_4(np->bst, np->bsh, o) 299 300 #define READSCRIPT_OFF(base, off) \ 301 (base ? *((volatile u_int32_t *)((volatile char *)base + (off))) : \ 302 bus_space_read_4(np->bst2, np->bsh2, off)) 303 304 #define WRITESCRIPT_OFF(base, off, val) \ 305 do { \ 306 if (base) \ 307 *((volatile u_int32_t *) \ 308 ((volatile char *)base + (off))) = (val); \ 309 else \ 310 bus_space_write_4(np->bst2, np->bsh2, off, val); \ 311 } while (0) 312 313 #define READSCRIPT(r) \ 314 READSCRIPT_OFF(np->script, offsetof(struct script, r)) 315 316 #define WRITESCRIPT(r, val) \ 317 WRITESCRIPT_OFF(np->script, offsetof(struct script, r), val) 318 319 /* 320 ** Set bit field ON, OFF 321 */ 322 323 #define OUTONB(r, m) OUTB(r, INB(r) | (m)) 324 #define OUTOFFB(r, m) OUTB(r, INB(r) & ~(m)) 325 #define OUTONW(r, m) OUTW(r, INW(r) | (m)) 326 #define OUTOFFW(r, m) OUTW(r, INW(r) & ~(m)) 327 #define OUTONL(r, m) OUTL(r, INL(r) | (m)) 328 #define OUTOFFL(r, m) OUTL(r, INL(r) & ~(m)) 329 330 /*========================================================== 331 ** 332 ** Command control block states. 333 ** 334 **========================================================== 335 */ 336 337 #define HS_IDLE (0) 338 #define HS_BUSY (1) 339 #define HS_NEGOTIATE (2) /* sync/wide data transfer*/ 340 #define HS_DISCONNECT (3) /* Disconnected by target */ 341 342 #define HS_COMPLETE (4) 343 #define HS_SEL_TIMEOUT (5) /* Selection timeout */ 344 #define HS_RESET (6) /* SCSI reset */ 345 #define HS_ABORTED (7) /* Transfer aborted */ 346 #define HS_TIMEOUT (8) /* Software timeout */ 347 #define HS_FAIL (9) /* SCSI or PCI bus errors */ 348 #define HS_UNEXPECTED (10) /* Unexpected disconnect */ 349 #define HS_STALL (11) /* QUEUE FULL or BUSY */ 350 351 #define HS_DONEMASK (0xfc) 352 353 /*========================================================== 354 ** 355 ** Software Interrupt Codes 356 ** 357 **========================================================== 358 */ 359 360 #define SIR_SENSE_RESTART (1) 361 #define SIR_SENSE_FAILED (2) 362 #define SIR_STALL_RESTART (3) 363 #define SIR_STALL_QUEUE (4) 364 #define SIR_NEGO_SYNC (5) 365 #define SIR_NEGO_WIDE (6) 366 #define SIR_NEGO_FAILED (7) 367 #define SIR_NEGO_PROTO (8) 368 #define SIR_REJECT_RECEIVED (9) 369 #define SIR_REJECT_SENT (10) 370 #define SIR_IGN_RESIDUE (11) 371 #define SIR_MISSING_SAVE (12) 372 #define SIR_MAX (12) 373 374 /*========================================================== 375 ** 376 ** Extended error codes. 377 ** xerr_status field of struct nccb. 378 ** 379 **========================================================== 380 */ 381 382 #define XE_OK (0) 383 #define XE_EXTRA_DATA (1) /* unexpected data phase */ 384 #define XE_BAD_PHASE (2) /* illegal phase (4/5) */ 385 386 /*========================================================== 387 ** 388 ** Negotiation status. 389 ** nego_status field of struct nccb. 390 ** 391 **========================================================== 392 */ 393 394 #define NS_SYNC (1) 395 #define NS_WIDE (2) 396 397 /*========================================================== 398 ** 399 ** XXX These are no longer used. Remove once the 400 ** script is updated. 401 ** "Special features" of targets. 402 ** quirks field of struct tcb. 403 ** actualquirks field of struct nccb. 404 ** 405 **========================================================== 406 */ 407 408 #define QUIRK_AUTOSAVE (0x01) 409 #define QUIRK_NOMSG (0x02) 410 #define QUIRK_NOSYNC (0x10) 411 #define QUIRK_NOWIDE16 (0x20) 412 #define QUIRK_NOTAGS (0x40) 413 #define QUIRK_UPDATE (0x80) 414 415 /*========================================================== 416 ** 417 ** Misc. 418 ** 419 **========================================================== 420 */ 421 422 #define CCB_MAGIC (0xf2691ad2) 423 #define MAX_TAGS (32) /* hard limit */ 424 425 /*========================================================== 426 ** 427 ** OS dependencies. 428 ** 429 **========================================================== 430 */ 431 432 #define PRINT_ADDR(ccb) xpt_print_path((ccb)->ccb_h.path) 433 434 /*========================================================== 435 ** 436 ** Declaration of structs. 437 ** 438 **========================================================== 439 */ 440 441 struct tcb; 442 struct lcb; 443 struct nccb; 444 struct ncb; 445 struct script; 446 447 typedef struct ncb * ncb_p; 448 typedef struct tcb * tcb_p; 449 typedef struct lcb * lcb_p; 450 typedef struct nccb * nccb_p; 451 452 struct link { 453 ncrcmd l_cmd; 454 ncrcmd l_paddr; 455 }; 456 457 struct usrcmd { 458 u_long target; 459 u_long lun; 460 u_long data; 461 u_long cmd; 462 }; 463 464 #define UC_SETSYNC 10 465 #define UC_SETTAGS 11 466 #define UC_SETDEBUG 12 467 #define UC_SETORDER 13 468 #define UC_SETWIDE 14 469 #define UC_SETFLAG 15 470 471 #define UF_TRACE (0x01) 472 473 /*--------------------------------------- 474 ** 475 ** Timestamps for profiling 476 ** 477 **--------------------------------------- 478 */ 479 480 /* Type of the kernel variable `ticks'. XXX should be declared with the var. */ 481 typedef int ticks_t; 482 483 struct tstamp { 484 ticks_t start; 485 ticks_t end; 486 ticks_t select; 487 ticks_t command; 488 ticks_t data; 489 ticks_t status; 490 ticks_t disconnect; 491 }; 492 493 /* 494 ** profiling data (per device) 495 */ 496 497 struct profile { 498 u_long num_trans; 499 u_long num_bytes; 500 u_long num_disc; 501 u_long num_break; 502 u_long num_int; 503 u_long num_fly; 504 u_long ms_setup; 505 u_long ms_data; 506 u_long ms_disc; 507 u_long ms_post; 508 }; 509 510 /*========================================================== 511 ** 512 ** Declaration of structs: target control block 513 ** 514 **========================================================== 515 */ 516 517 #define NCR_TRANS_CUR 0x01 /* Modify current neogtiation status */ 518 #define NCR_TRANS_ACTIVE 0x03 /* Assume this is the active target */ 519 #define NCR_TRANS_GOAL 0x04 /* Modify negotiation goal */ 520 #define NCR_TRANS_USER 0x08 /* Modify user negotiation settings */ 521 522 struct ncr_transinfo { 523 u_int8_t width; 524 u_int8_t period; 525 u_int8_t offset; 526 }; 527 528 struct ncr_target_tinfo { 529 /* Hardware version of our sync settings */ 530 u_int8_t disc_tag; 531 #define NCR_CUR_DISCENB 0x01 532 #define NCR_CUR_TAGENB 0x02 533 #define NCR_USR_DISCENB 0x04 534 #define NCR_USR_TAGENB 0x08 535 u_int8_t sval; 536 struct ncr_transinfo current; 537 struct ncr_transinfo goal; 538 struct ncr_transinfo user; 539 /* Hardware version of our wide settings */ 540 u_int8_t wval; 541 }; 542 543 struct tcb { 544 /* 545 ** during reselection the ncr jumps to this point 546 ** with SFBR set to the encoded target number 547 ** with bit 7 set. 548 ** if it's not this target, jump to the next. 549 ** 550 ** JUMP IF (SFBR != #target#) 551 ** @(next tcb) 552 */ 553 554 struct link jump_tcb; 555 556 /* 557 ** load the actual values for the sxfer and the scntl3 558 ** register (sync/wide mode). 559 ** 560 ** SCR_COPY (1); 561 ** @(sval field of this tcb) 562 ** @(sxfer register) 563 ** SCR_COPY (1); 564 ** @(wval field of this tcb) 565 ** @(scntl3 register) 566 */ 567 568 ncrcmd getscr[6]; 569 570 /* 571 ** if next message is "identify" 572 ** then load the message to SFBR, 573 ** else load 0 to SFBR. 574 ** 575 ** CALL 576 ** <RESEL_LUN> 577 */ 578 579 struct link call_lun; 580 581 /* 582 ** now look for the right lun. 583 ** 584 ** JUMP 585 ** @(first nccb of this lun) 586 */ 587 588 struct link jump_lcb; 589 590 /* 591 ** pointer to interrupted getcc nccb 592 */ 593 594 nccb_p hold_cp; 595 596 /* 597 ** pointer to nccb used for negotiating. 598 ** Avoid to start a nego for all queued commands 599 ** when tagged command queuing is enabled. 600 */ 601 602 nccb_p nego_cp; 603 604 /* 605 ** statistical data 606 */ 607 608 u_long transfers; 609 u_long bytes; 610 611 /* 612 ** user settable limits for sync transfer 613 ** and tagged commands. 614 */ 615 616 struct ncr_target_tinfo tinfo; 617 618 /* 619 ** the lcb's of this tcb 620 */ 621 622 lcb_p lp[MAX_LUN]; 623 }; 624 625 /*========================================================== 626 ** 627 ** Declaration of structs: lun control block 628 ** 629 **========================================================== 630 */ 631 632 struct lcb { 633 /* 634 ** during reselection the ncr jumps to this point 635 ** with SFBR set to the "Identify" message. 636 ** if it's not this lun, jump to the next. 637 ** 638 ** JUMP IF (SFBR != #lun#) 639 ** @(next lcb of this target) 640 */ 641 642 struct link jump_lcb; 643 644 /* 645 ** if next message is "simple tag", 646 ** then load the tag to SFBR, 647 ** else load 0 to SFBR. 648 ** 649 ** CALL 650 ** <RESEL_TAG> 651 */ 652 653 struct link call_tag; 654 655 /* 656 ** now look for the right nccb. 657 ** 658 ** JUMP 659 ** @(first nccb of this lun) 660 */ 661 662 struct link jump_nccb; 663 664 /* 665 ** start of the nccb chain 666 */ 667 668 nccb_p next_nccb; 669 670 /* 671 ** Control of tagged queueing 672 */ 673 674 u_char reqnccbs; 675 u_char reqlink; 676 u_char actlink; 677 u_char usetags; 678 u_char lasttag; 679 }; 680 681 /*========================================================== 682 ** 683 ** Declaration of structs: COMMAND control block 684 ** 685 **========================================================== 686 ** 687 ** This substructure is copied from the nccb to a 688 ** global address after selection (or reselection) 689 ** and copied back before disconnect. 690 ** 691 ** These fields are accessible to the script processor. 692 ** 693 **---------------------------------------------------------- 694 */ 695 696 struct head { 697 /* 698 ** Execution of a nccb starts at this point. 699 ** It's a jump to the "SELECT" label 700 ** of the script. 701 ** 702 ** After successful selection the script 703 ** processor overwrites it with a jump to 704 ** the IDLE label of the script. 705 */ 706 707 struct link launch; 708 709 /* 710 ** Saved data pointer. 711 ** Points to the position in the script 712 ** responsible for the actual transfer 713 ** of data. 714 ** It's written after reception of a 715 ** "SAVE_DATA_POINTER" message. 716 ** The goalpointer points after 717 ** the last transfer command. 718 */ 719 720 u_int32_t savep; 721 u_int32_t lastp; 722 u_int32_t goalp; 723 724 /* 725 ** The virtual address of the nccb 726 ** containing this header. 727 */ 728 729 nccb_p cp; 730 731 /* 732 ** space for some timestamps to gather 733 ** profiling data about devices and this driver. 734 */ 735 736 struct tstamp stamp; 737 738 /* 739 ** status fields. 740 */ 741 742 u_char status[8]; 743 }; 744 745 /* 746 ** The status bytes are used by the host and the script processor. 747 ** 748 ** The first four byte are copied to the scratchb register 749 ** (declared as scr0..scr3 in ncr_reg.h) just after the select/reselect, 750 ** and copied back just after disconnecting. 751 ** Inside the script the XX_REG are used. 752 ** 753 ** The last four bytes are used inside the script by "COPY" commands. 754 ** Because source and destination must have the same alignment 755 ** in a longword, the fields HAVE to be at the choosen offsets. 756 ** xerr_st (4) 0 (0x34) scratcha 757 ** sync_st (5) 1 (0x05) sxfer 758 ** wide_st (7) 3 (0x03) scntl3 759 */ 760 761 /* 762 ** First four bytes (script) 763 */ 764 #define QU_REG scr0 765 #define HS_REG scr1 766 #define HS_PRT nc_scr1 767 #define SS_REG scr2 768 #define PS_REG scr3 769 770 /* 771 ** First four bytes (host) 772 */ 773 #define actualquirks phys.header.status[0] 774 #define host_status phys.header.status[1] 775 #define s_status phys.header.status[2] 776 #define parity_status phys.header.status[3] 777 778 /* 779 ** Last four bytes (script) 780 */ 781 #define xerr_st header.status[4] /* MUST be ==0 mod 4 */ 782 #define sync_st header.status[5] /* MUST be ==1 mod 4 */ 783 #define nego_st header.status[6] 784 #define wide_st header.status[7] /* MUST be ==3 mod 4 */ 785 786 /* 787 ** Last four bytes (host) 788 */ 789 #define xerr_status phys.xerr_st 790 #define sync_status phys.sync_st 791 #define nego_status phys.nego_st 792 #define wide_status phys.wide_st 793 794 /*========================================================== 795 ** 796 ** Declaration of structs: Data structure block 797 ** 798 **========================================================== 799 ** 800 ** During execution of a nccb by the script processor, 801 ** the DSA (data structure address) register points 802 ** to this substructure of the nccb. 803 ** This substructure contains the header with 804 ** the script-processor-changable data and 805 ** data blocks for the indirect move commands. 806 ** 807 **---------------------------------------------------------- 808 */ 809 810 struct dsb { 811 812 /* 813 ** Header. 814 ** Has to be the first entry, 815 ** because it's jumped to by the 816 ** script processor 817 */ 818 819 struct head header; 820 821 /* 822 ** Table data for Script 823 */ 824 825 struct scr_tblsel select; 826 struct scr_tblmove smsg ; 827 struct scr_tblmove smsg2 ; 828 struct scr_tblmove cmd ; 829 struct scr_tblmove scmd ; 830 struct scr_tblmove sense ; 831 struct scr_tblmove data [MAX_SCATTER]; 832 }; 833 834 /*========================================================== 835 ** 836 ** Declaration of structs: Command control block. 837 ** 838 **========================================================== 839 ** 840 ** During execution of a nccb by the script processor, 841 ** the DSA (data structure address) register points 842 ** to this substructure of the nccb. 843 ** This substructure contains the header with 844 ** the script-processor-changable data and then 845 ** data blocks for the indirect move commands. 846 ** 847 **---------------------------------------------------------- 848 */ 849 850 851 struct nccb { 852 /* 853 ** This filler ensures that the global header is 854 ** cache line size aligned. 855 */ 856 ncrcmd filler[4]; 857 858 /* 859 ** during reselection the ncr jumps to this point. 860 ** If a "SIMPLE_TAG" message was received, 861 ** then SFBR is set to the tag. 862 ** else SFBR is set to 0 863 ** If looking for another tag, jump to the next nccb. 864 ** 865 ** JUMP IF (SFBR != #TAG#) 866 ** @(next nccb of this lun) 867 */ 868 869 struct link jump_nccb; 870 871 /* 872 ** After execution of this call, the return address 873 ** (in the TEMP register) points to the following 874 ** data structure block. 875 ** So copy it to the DSA register, and start 876 ** processing of this data structure. 877 ** 878 ** CALL 879 ** <RESEL_TMP> 880 */ 881 882 struct link call_tmp; 883 884 /* 885 ** This is the data structure which is 886 ** to be executed by the script processor. 887 */ 888 889 struct dsb phys; 890 891 /* 892 ** If a data transfer phase is terminated too early 893 ** (after reception of a message (i.e. DISCONNECT)), 894 ** we have to prepare a mini script to transfer 895 ** the rest of the data. 896 */ 897 898 ncrcmd patch[8]; 899 900 /* 901 ** The general SCSI driver provides a 902 ** pointer to a control block. 903 */ 904 905 union ccb *ccb; 906 907 /* 908 ** We prepare a message to be sent after selection, 909 ** and a second one to be sent after getcc selection. 910 ** Contents are IDENTIFY and SIMPLE_TAG. 911 ** While negotiating sync or wide transfer, 912 ** a SDTM or WDTM message is appended. 913 */ 914 915 u_char scsi_smsg [8]; 916 u_char scsi_smsg2[8]; 917 918 /* 919 ** Lock this nccb. 920 ** Flag is used while looking for a free nccb. 921 */ 922 923 u_long magic; 924 925 /* 926 ** Physical address of this instance of nccb 927 */ 928 929 u_long p_nccb; 930 931 /* 932 ** Completion time out for this job. 933 ** It's set to time of start + allowed number of seconds. 934 */ 935 936 time_t tlimit; 937 938 /* 939 ** All nccbs of one hostadapter are chained. 940 */ 941 942 nccb_p link_nccb; 943 944 /* 945 ** All nccbs of one target/lun are chained. 946 */ 947 948 nccb_p next_nccb; 949 950 /* 951 ** Sense command 952 */ 953 954 u_char sensecmd[6]; 955 956 /* 957 ** Tag for this transfer. 958 ** It's patched into jump_nccb. 959 ** If it's not zero, a SIMPLE_TAG 960 ** message is included in smsg. 961 */ 962 963 u_char tag; 964 }; 965 966 #define CCB_PHYS(cp,lbl) (cp->p_nccb + offsetof(struct nccb, lbl)) 967 968 /*========================================================== 969 ** 970 ** Declaration of structs: NCR device descriptor 971 ** 972 **========================================================== 973 */ 974 975 struct ncb { 976 /* 977 ** The global header. 978 ** Accessible to both the host and the 979 ** script-processor. 980 ** We assume it is cache line size aligned. 981 */ 982 struct head header; 983 984 int unit; 985 986 /*----------------------------------------------- 987 ** Scripts .. 988 **----------------------------------------------- 989 ** 990 ** During reselection the ncr jumps to this point. 991 ** The SFBR register is loaded with the encoded target id. 992 ** 993 ** Jump to the first target. 994 ** 995 ** JUMP 996 ** @(next tcb) 997 */ 998 struct link jump_tcb; 999 1000 /*----------------------------------------------- 1001 ** Configuration .. 1002 **----------------------------------------------- 1003 ** 1004 ** virtual and physical addresses 1005 ** of the 53c810 chip. 1006 */ 1007 int reg_rid; 1008 struct resource *reg_res; 1009 bus_space_tag_t bst; 1010 bus_space_handle_t bsh; 1011 1012 int sram_rid; 1013 struct resource *sram_res; 1014 bus_space_tag_t bst2; 1015 bus_space_handle_t bsh2; 1016 1017 struct resource *irq_res; 1018 void *irq_handle; 1019 1020 /* 1021 ** Scripts instance virtual address. 1022 */ 1023 struct script *script; 1024 struct scripth *scripth; 1025 1026 /* 1027 ** Scripts instance physical address. 1028 */ 1029 u_long p_script; 1030 u_long p_scripth; 1031 1032 /* 1033 ** The SCSI address of the host adapter. 1034 */ 1035 u_char myaddr; 1036 1037 /* 1038 ** timing parameters 1039 */ 1040 u_char minsync; /* Minimum sync period factor */ 1041 u_char maxsync; /* Maximum sync period factor */ 1042 u_char maxoffs; /* Max scsi offset */ 1043 u_char clock_divn; /* Number of clock divisors */ 1044 u_long clock_khz; /* SCSI clock frequency in KHz */ 1045 u_long features; /* Chip features map */ 1046 u_char multiplier; /* Clock multiplier (1,2,4) */ 1047 1048 u_char maxburst; /* log base 2 of dwords burst */ 1049 1050 /* 1051 ** BIOS supplied PCI bus options 1052 */ 1053 u_char rv_scntl3; 1054 u_char rv_dcntl; 1055 u_char rv_dmode; 1056 u_char rv_ctest3; 1057 u_char rv_ctest4; 1058 u_char rv_ctest5; 1059 u_char rv_gpcntl; 1060 u_char rv_stest2; 1061 1062 /*----------------------------------------------- 1063 ** CAM SIM information for this instance 1064 **----------------------------------------------- 1065 */ 1066 1067 struct cam_sim *sim; 1068 struct cam_path *path; 1069 1070 /*----------------------------------------------- 1071 ** Job control 1072 **----------------------------------------------- 1073 ** 1074 ** Commands from user 1075 */ 1076 struct usrcmd user; 1077 1078 /* 1079 ** Target data 1080 */ 1081 struct tcb target[MAX_TARGET]; 1082 1083 /* 1084 ** Start queue. 1085 */ 1086 u_int32_t squeue [MAX_START]; 1087 u_short squeueput; 1088 1089 /* 1090 ** Timeout handler 1091 */ 1092 time_t heartbeat; 1093 u_short ticks; 1094 u_short latetime; 1095 time_t lasttime; 1096 struct callout_handle timeout_ch; 1097 1098 /*----------------------------------------------- 1099 ** Debug and profiling 1100 **----------------------------------------------- 1101 ** 1102 ** register dump 1103 */ 1104 struct ncr_reg regdump; 1105 time_t regtime; 1106 1107 /* 1108 ** Profiling data 1109 */ 1110 struct profile profile; 1111 u_long disc_phys; 1112 u_long disc_ref; 1113 1114 /* 1115 ** Head of list of all nccbs for this controller. 1116 */ 1117 nccb_p link_nccb; 1118 1119 /* 1120 ** message buffers. 1121 ** Should be longword aligned, 1122 ** because they're written with a 1123 ** COPY script command. 1124 */ 1125 u_char msgout[8]; 1126 u_char msgin [8]; 1127 u_int32_t lastmsg; 1128 1129 /* 1130 ** Buffer for STATUS_IN phase. 1131 */ 1132 u_char scratch; 1133 1134 /* 1135 ** controller chip dependent maximal transfer width. 1136 */ 1137 u_char maxwide; 1138 1139 #ifdef NCR_IOMAPPED 1140 /* 1141 ** address of the ncr control registers in io space 1142 */ 1143 pci_port_t port; 1144 #endif 1145 }; 1146 1147 #define NCB_SCRIPT_PHYS(np,lbl) (np->p_script + offsetof (struct script, lbl)) 1148 #define NCB_SCRIPTH_PHYS(np,lbl) (np->p_scripth + offsetof (struct scripth,lbl)) 1149 1150 /*========================================================== 1151 ** 1152 ** 1153 ** Script for NCR-Processor. 1154 ** 1155 ** Use ncr_script_fill() to create the variable parts. 1156 ** Use ncr_script_copy_and_bind() to make a copy and 1157 ** bind to physical addresses. 1158 ** 1159 ** 1160 **========================================================== 1161 ** 1162 ** We have to know the offsets of all labels before 1163 ** we reach them (for forward jumps). 1164 ** Therefore we declare a struct here. 1165 ** If you make changes inside the script, 1166 ** DONT FORGET TO CHANGE THE LENGTHS HERE! 1167 ** 1168 **---------------------------------------------------------- 1169 */ 1170 1171 /* 1172 ** Script fragments which are loaded into the on-board RAM 1173 ** of 825A, 875 and 895 chips. 1174 */ 1175 struct script { 1176 ncrcmd start [ 7]; 1177 ncrcmd start0 [ 2]; 1178 ncrcmd start1 [ 3]; 1179 ncrcmd startpos [ 1]; 1180 ncrcmd trysel [ 8]; 1181 ncrcmd skip [ 8]; 1182 ncrcmd skip2 [ 3]; 1183 ncrcmd idle [ 2]; 1184 ncrcmd select [ 18]; 1185 ncrcmd prepare [ 4]; 1186 ncrcmd loadpos [ 14]; 1187 ncrcmd prepare2 [ 24]; 1188 ncrcmd setmsg [ 5]; 1189 ncrcmd clrack [ 2]; 1190 ncrcmd dispatch [ 33]; 1191 ncrcmd no_data [ 17]; 1192 ncrcmd checkatn [ 10]; 1193 ncrcmd command [ 15]; 1194 ncrcmd status [ 27]; 1195 ncrcmd msg_in [ 26]; 1196 ncrcmd msg_bad [ 6]; 1197 ncrcmd complete [ 13]; 1198 ncrcmd cleanup [ 12]; 1199 ncrcmd cleanup0 [ 9]; 1200 ncrcmd signal [ 12]; 1201 ncrcmd save_dp [ 5]; 1202 ncrcmd restore_dp [ 5]; 1203 ncrcmd disconnect [ 12]; 1204 ncrcmd disconnect0 [ 5]; 1205 ncrcmd disconnect1 [ 23]; 1206 ncrcmd msg_out [ 9]; 1207 ncrcmd msg_out_done [ 7]; 1208 ncrcmd badgetcc [ 6]; 1209 ncrcmd reselect [ 8]; 1210 ncrcmd reselect1 [ 8]; 1211 ncrcmd reselect2 [ 8]; 1212 ncrcmd resel_tmp [ 5]; 1213 ncrcmd resel_lun [ 18]; 1214 ncrcmd resel_tag [ 24]; 1215 ncrcmd data_in [MAX_SCATTER * 4 + 7]; 1216 ncrcmd data_out [MAX_SCATTER * 4 + 7]; 1217 }; 1218 1219 /* 1220 ** Script fragments which stay in main memory for all chips. 1221 */ 1222 struct scripth { 1223 ncrcmd tryloop [MAX_START*5+2]; 1224 ncrcmd msg_parity [ 6]; 1225 ncrcmd msg_reject [ 8]; 1226 ncrcmd msg_ign_residue [ 32]; 1227 ncrcmd msg_extended [ 18]; 1228 ncrcmd msg_ext_2 [ 18]; 1229 ncrcmd msg_wdtr [ 27]; 1230 ncrcmd msg_ext_3 [ 18]; 1231 ncrcmd msg_sdtr [ 27]; 1232 ncrcmd msg_out_abort [ 10]; 1233 ncrcmd getcc [ 4]; 1234 ncrcmd getcc1 [ 5]; 1235 #ifdef NCR_GETCC_WITHMSG 1236 ncrcmd getcc2 [ 29]; 1237 #else 1238 ncrcmd getcc2 [ 14]; 1239 #endif 1240 ncrcmd getcc3 [ 6]; 1241 ncrcmd aborttag [ 4]; 1242 ncrcmd abort [ 22]; 1243 ncrcmd snooptest [ 9]; 1244 ncrcmd snoopend [ 2]; 1245 }; 1246 1247 /*========================================================== 1248 ** 1249 ** 1250 ** Function headers. 1251 ** 1252 ** 1253 **========================================================== 1254 */ 1255 1256 #ifdef _KERNEL 1257 static nccb_p ncr_alloc_nccb (ncb_p np, u_long target, u_long lun); 1258 static void ncr_complete (ncb_p np, nccb_p cp); 1259 static int ncr_delta (int * from, int * to); 1260 static void ncr_exception (ncb_p np); 1261 static void ncr_free_nccb (ncb_p np, nccb_p cp); 1262 static void ncr_freeze_devq (ncb_p np, struct cam_path *path); 1263 static void ncr_selectclock (ncb_p np, u_char scntl3); 1264 static void ncr_getclock (ncb_p np, u_char multiplier); 1265 static nccb_p ncr_get_nccb (ncb_p np, u_long t,u_long l); 1266 #if 0 1267 static u_int32_t ncr_info (int unit); 1268 #endif 1269 static void ncr_init (ncb_p np, char * msg, u_long code); 1270 static void ncr_intr (void *vnp); 1271 static void ncr_int_ma (ncb_p np, u_char dstat); 1272 static void ncr_int_sir (ncb_p np); 1273 static void ncr_int_sto (ncb_p np); 1274 #if 0 1275 static void ncr_min_phys (struct buf *bp); 1276 #endif 1277 static void ncr_poll (struct cam_sim *sim); 1278 static void ncb_profile (ncb_p np, nccb_p cp); 1279 static void ncr_script_copy_and_bind 1280 (ncb_p np, ncrcmd *src, ncrcmd *dst, int len); 1281 static void ncr_script_fill (struct script * scr, struct scripth *scrh); 1282 static int ncr_scatter (struct dsb* phys, vm_offset_t vaddr, 1283 vm_size_t datalen); 1284 static void ncr_getsync (ncb_p np, u_char sfac, u_char *fakp, 1285 u_char *scntl3p); 1286 static void ncr_setsync (ncb_p np, nccb_p cp,u_char scntl3,u_char sxfer, 1287 u_char period); 1288 static void ncr_setwide (ncb_p np, nccb_p cp, u_char wide, u_char ack); 1289 static int ncr_show_msg (u_char * msg); 1290 static int ncr_snooptest (ncb_p np); 1291 static void ncr_action (struct cam_sim *sim, union ccb *ccb); 1292 static void ncr_timeout (void *arg); 1293 static void ncr_wakeup (ncb_p np, u_long code); 1294 1295 static int ncr_probe (device_t dev); 1296 static int ncr_attach (device_t dev); 1297 1298 #endif /* _KERNEL */ 1299 1300 /*========================================================== 1301 ** 1302 ** 1303 ** Global static data. 1304 ** 1305 ** 1306 **========================================================== 1307 */ 1308 1309 1310 /* 1311 * $FreeBSD: src/sys/pci/ncr.c,v 1.155.2.3 2001/03/05 13:09:10 obrien Exp $ 1312 */ 1313 static const u_long ncr_version = NCR_VERSION * 11 1314 + (u_long) sizeof (struct ncb) * 7 1315 + (u_long) sizeof (struct nccb) * 5 1316 + (u_long) sizeof (struct lcb) * 3 1317 + (u_long) sizeof (struct tcb) * 2; 1318 1319 #ifdef _KERNEL 1320 1321 static int ncr_debug = SCSI_NCR_DEBUG; 1322 SYSCTL_INT(_debug, OID_AUTO, ncr_debug, CTLFLAG_RW, &ncr_debug, 0, ""); 1323 1324 static int ncr_cache; /* to be aligned _NOT_ static */ 1325 1326 /*========================================================== 1327 ** 1328 ** 1329 ** Global static data: auto configure 1330 ** 1331 ** 1332 **========================================================== 1333 */ 1334 1335 #define NCR_810_ID (0x00011000ul) 1336 #define NCR_815_ID (0x00041000ul) 1337 #define NCR_820_ID (0x00021000ul) 1338 #define NCR_825_ID (0x00031000ul) 1339 #define NCR_860_ID (0x00061000ul) 1340 #define NCR_875_ID (0x000f1000ul) 1341 #define NCR_875_ID2 (0x008f1000ul) 1342 #define NCR_885_ID (0x000d1000ul) 1343 #define NCR_895_ID (0x000c1000ul) 1344 #define NCR_896_ID (0x000b1000ul) 1345 #define NCR_895A_ID (0x00121000ul) 1346 #define NCR_1510D_ID (0x000a1000ul) 1347 1348 1349 static char *ncr_name (ncb_p np) 1350 { 1351 static char name[10]; 1352 snprintf(name, sizeof(name), "ncr%d", np->unit); 1353 return (name); 1354 } 1355 1356 /*========================================================== 1357 ** 1358 ** 1359 ** Scripts for NCR-Processor. 1360 ** 1361 ** Use ncr_script_bind for binding to physical addresses. 1362 ** 1363 ** 1364 **========================================================== 1365 ** 1366 ** NADDR generates a reference to a field of the controller data. 1367 ** PADDR generates a reference to another part of the script. 1368 ** RADDR generates a reference to a script processor register. 1369 ** FADDR generates a reference to a script processor register 1370 ** with offset. 1371 ** 1372 **---------------------------------------------------------- 1373 */ 1374 1375 #define RELOC_SOFTC 0x40000000 1376 #define RELOC_LABEL 0x50000000 1377 #define RELOC_REGISTER 0x60000000 1378 #define RELOC_KVAR 0x70000000 1379 #define RELOC_LABELH 0x80000000 1380 #define RELOC_MASK 0xf0000000 1381 1382 #define NADDR(label) (RELOC_SOFTC | offsetof(struct ncb, label)) 1383 #define PADDR(label) (RELOC_LABEL | offsetof(struct script, label)) 1384 #define PADDRH(label) (RELOC_LABELH | offsetof(struct scripth, label)) 1385 #define RADDR(label) (RELOC_REGISTER | REG(label)) 1386 #define FADDR(label,ofs)(RELOC_REGISTER | ((REG(label))+(ofs))) 1387 #define KVAR(which) (RELOC_KVAR | (which)) 1388 1389 #define KVAR_SECOND (0) 1390 #define KVAR_TICKS (1) 1391 #define KVAR_NCR_CACHE (2) 1392 1393 #define SCRIPT_KVAR_FIRST (0) 1394 #define SCRIPT_KVAR_LAST (3) 1395 1396 /* 1397 * Kernel variables referenced in the scripts. 1398 * THESE MUST ALL BE ALIGNED TO A 4-BYTE BOUNDARY. 1399 */ 1400 static void *script_kvars[] = 1401 { &time_second, &ticks, &ncr_cache }; 1402 1403 static struct script script0 = { 1404 /*--------------------------< START >-----------------------*/ { 1405 /* 1406 ** Claim to be still alive ... 1407 */ 1408 SCR_COPY (sizeof (((struct ncb *)0)->heartbeat)), 1409 KVAR (KVAR_SECOND), 1410 NADDR (heartbeat), 1411 /* 1412 ** Make data structure address invalid. 1413 ** clear SIGP. 1414 */ 1415 SCR_LOAD_REG (dsa, 0xff), 1416 0, 1417 SCR_FROM_REG (ctest2), 1418 0, 1419 }/*-------------------------< START0 >----------------------*/,{ 1420 /* 1421 ** Hook for interrupted GetConditionCode. 1422 ** Will be patched to ... IFTRUE by 1423 ** the interrupt handler. 1424 */ 1425 SCR_INT ^ IFFALSE (0), 1426 SIR_SENSE_RESTART, 1427 1428 }/*-------------------------< START1 >----------------------*/,{ 1429 /* 1430 ** Hook for stalled start queue. 1431 ** Will be patched to IFTRUE by the interrupt handler. 1432 */ 1433 SCR_INT ^ IFFALSE (0), 1434 SIR_STALL_RESTART, 1435 /* 1436 ** Then jump to a certain point in tryloop. 1437 ** Due to the lack of indirect addressing the code 1438 ** is self modifying here. 1439 */ 1440 SCR_JUMP, 1441 }/*-------------------------< STARTPOS >--------------------*/,{ 1442 PADDRH(tryloop), 1443 1444 }/*-------------------------< TRYSEL >----------------------*/,{ 1445 /* 1446 ** Now: 1447 ** DSA: Address of a Data Structure 1448 ** or Address of the IDLE-Label. 1449 ** 1450 ** TEMP: Address of a script, which tries to 1451 ** start the NEXT entry. 1452 ** 1453 ** Save the TEMP register into the SCRATCHA register. 1454 ** Then copy the DSA to TEMP and RETURN. 1455 ** This is kind of an indirect jump. 1456 ** (The script processor has NO stack, so the 1457 ** CALL is actually a jump and link, and the 1458 ** RETURN is an indirect jump.) 1459 ** 1460 ** If the slot was empty, DSA contains the address 1461 ** of the IDLE part of this script. The processor 1462 ** jumps to IDLE and waits for a reselect. 1463 ** It will wake up and try the same slot again 1464 ** after the SIGP bit becomes set by the host. 1465 ** 1466 ** If the slot was not empty, DSA contains 1467 ** the address of the phys-part of a nccb. 1468 ** The processor jumps to this address. 1469 ** phys starts with head, 1470 ** head starts with launch, 1471 ** so actually the processor jumps to 1472 ** the lauch part. 1473 ** If the entry is scheduled for execution, 1474 ** then launch contains a jump to SELECT. 1475 ** If it's not scheduled, it contains a jump to IDLE. 1476 */ 1477 SCR_COPY (4), 1478 RADDR (temp), 1479 RADDR (scratcha), 1480 SCR_COPY (4), 1481 RADDR (dsa), 1482 RADDR (temp), 1483 SCR_RETURN, 1484 0 1485 1486 }/*-------------------------< SKIP >------------------------*/,{ 1487 /* 1488 ** This entry has been canceled. 1489 ** Next time use the next slot. 1490 */ 1491 SCR_COPY (4), 1492 RADDR (scratcha), 1493 PADDR (startpos), 1494 /* 1495 ** patch the launch field. 1496 ** should look like an idle process. 1497 */ 1498 SCR_COPY_F (4), 1499 RADDR (dsa), 1500 PADDR (skip2), 1501 SCR_COPY (8), 1502 PADDR (idle), 1503 }/*-------------------------< SKIP2 >-----------------------*/,{ 1504 0, 1505 SCR_JUMP, 1506 PADDR(start), 1507 }/*-------------------------< IDLE >------------------------*/,{ 1508 /* 1509 ** Nothing to do? 1510 ** Wait for reselect. 1511 */ 1512 SCR_JUMP, 1513 PADDR(reselect), 1514 1515 }/*-------------------------< SELECT >----------------------*/,{ 1516 /* 1517 ** DSA contains the address of a scheduled 1518 ** data structure. 1519 ** 1520 ** SCRATCHA contains the address of the script, 1521 ** which starts the next entry. 1522 ** 1523 ** Set Initiator mode. 1524 ** 1525 ** (Target mode is left as an exercise for the reader) 1526 */ 1527 1528 SCR_CLR (SCR_TRG), 1529 0, 1530 SCR_LOAD_REG (HS_REG, 0xff), 1531 0, 1532 1533 /* 1534 ** And try to select this target. 1535 */ 1536 SCR_SEL_TBL_ATN ^ offsetof (struct dsb, select), 1537 PADDR (reselect), 1538 1539 /* 1540 ** Now there are 4 possibilities: 1541 ** 1542 ** (1) The ncr looses arbitration. 1543 ** This is ok, because it will try again, 1544 ** when the bus becomes idle. 1545 ** (But beware of the timeout function!) 1546 ** 1547 ** (2) The ncr is reselected. 1548 ** Then the script processor takes the jump 1549 ** to the RESELECT label. 1550 ** 1551 ** (3) The ncr completes the selection. 1552 ** Then it will execute the next statement. 1553 ** 1554 ** (4) There is a selection timeout. 1555 ** Then the ncr should interrupt the host and stop. 1556 ** Unfortunately, it seems to continue execution 1557 ** of the script. But it will fail with an 1558 ** IID-interrupt on the next WHEN. 1559 */ 1560 1561 SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_IN)), 1562 0, 1563 1564 /* 1565 ** Send the IDENTIFY and SIMPLE_TAG messages 1566 ** (and the MSG_EXT_SDTR message) 1567 */ 1568 SCR_MOVE_TBL ^ SCR_MSG_OUT, 1569 offsetof (struct dsb, smsg), 1570 #ifdef undef /* XXX better fail than try to deal with this ... */ 1571 SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_OUT)), 1572 -16, 1573 #endif 1574 SCR_CLR (SCR_ATN), 1575 0, 1576 SCR_COPY (1), 1577 RADDR (sfbr), 1578 NADDR (lastmsg), 1579 /* 1580 ** Selection complete. 1581 ** Next time use the next slot. 1582 */ 1583 SCR_COPY (4), 1584 RADDR (scratcha), 1585 PADDR (startpos), 1586 }/*-------------------------< PREPARE >----------------------*/,{ 1587 /* 1588 ** The ncr doesn't have an indirect load 1589 ** or store command. So we have to 1590 ** copy part of the control block to a 1591 ** fixed place, where we can access it. 1592 ** 1593 ** We patch the address part of a 1594 ** COPY command with the DSA-register. 1595 */ 1596 SCR_COPY_F (4), 1597 RADDR (dsa), 1598 PADDR (loadpos), 1599 /* 1600 ** then we do the actual copy. 1601 */ 1602 SCR_COPY (sizeof (struct head)), 1603 /* 1604 ** continued after the next label ... 1605 */ 1606 1607 }/*-------------------------< LOADPOS >---------------------*/,{ 1608 0, 1609 NADDR (header), 1610 /* 1611 ** Mark this nccb as not scheduled. 1612 */ 1613 SCR_COPY (8), 1614 PADDR (idle), 1615 NADDR (header.launch), 1616 /* 1617 ** Set a time stamp for this selection 1618 */ 1619 SCR_COPY (sizeof (ticks)), 1620 KVAR (KVAR_TICKS), 1621 NADDR (header.stamp.select), 1622 /* 1623 ** load the savep (saved pointer) into 1624 ** the TEMP register (actual pointer) 1625 */ 1626 SCR_COPY (4), 1627 NADDR (header.savep), 1628 RADDR (temp), 1629 /* 1630 ** Initialize the status registers 1631 */ 1632 SCR_COPY (4), 1633 NADDR (header.status), 1634 RADDR (scr0), 1635 1636 }/*-------------------------< PREPARE2 >---------------------*/,{ 1637 /* 1638 ** Load the synchronous mode register 1639 */ 1640 SCR_COPY (1), 1641 NADDR (sync_st), 1642 RADDR (sxfer), 1643 /* 1644 ** Load the wide mode and timing register 1645 */ 1646 SCR_COPY (1), 1647 NADDR (wide_st), 1648 RADDR (scntl3), 1649 /* 1650 ** Initialize the msgout buffer with a NOOP message. 1651 */ 1652 SCR_LOAD_REG (scratcha, MSG_NOOP), 1653 0, 1654 SCR_COPY (1), 1655 RADDR (scratcha), 1656 NADDR (msgout), 1657 SCR_COPY (1), 1658 RADDR (scratcha), 1659 NADDR (msgin), 1660 /* 1661 ** Message in phase ? 1662 */ 1663 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)), 1664 PADDR (dispatch), 1665 /* 1666 ** Extended or reject message ? 1667 */ 1668 SCR_FROM_REG (sbdl), 1669 0, 1670 SCR_JUMP ^ IFTRUE (DATA (MSG_EXTENDED)), 1671 PADDR (msg_in), 1672 SCR_JUMP ^ IFTRUE (DATA (MSG_MESSAGE_REJECT)), 1673 PADDRH (msg_reject), 1674 /* 1675 ** normal processing 1676 */ 1677 SCR_JUMP, 1678 PADDR (dispatch), 1679 }/*-------------------------< SETMSG >----------------------*/,{ 1680 SCR_COPY (1), 1681 RADDR (scratcha), 1682 NADDR (msgout), 1683 SCR_SET (SCR_ATN), 1684 0, 1685 }/*-------------------------< CLRACK >----------------------*/,{ 1686 /* 1687 ** Terminate possible pending message phase. 1688 */ 1689 SCR_CLR (SCR_ACK), 1690 0, 1691 1692 }/*-----------------------< DISPATCH >----------------------*/,{ 1693 SCR_FROM_REG (HS_REG), 1694 0, 1695 SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)), 1696 SIR_NEGO_FAILED, 1697 /* 1698 ** remove bogus output signals 1699 */ 1700 SCR_REG_REG (socl, SCR_AND, CACK|CATN), 1701 0, 1702 SCR_RETURN ^ IFTRUE (WHEN (SCR_DATA_OUT)), 1703 0, 1704 SCR_RETURN ^ IFTRUE (IF (SCR_DATA_IN)), 1705 0, 1706 SCR_JUMP ^ IFTRUE (IF (SCR_MSG_OUT)), 1707 PADDR (msg_out), 1708 SCR_JUMP ^ IFTRUE (IF (SCR_MSG_IN)), 1709 PADDR (msg_in), 1710 SCR_JUMP ^ IFTRUE (IF (SCR_COMMAND)), 1711 PADDR (command), 1712 SCR_JUMP ^ IFTRUE (IF (SCR_STATUS)), 1713 PADDR (status), 1714 /* 1715 ** Discard one illegal phase byte, if required. 1716 */ 1717 SCR_LOAD_REG (scratcha, XE_BAD_PHASE), 1718 0, 1719 SCR_COPY (1), 1720 RADDR (scratcha), 1721 NADDR (xerr_st), 1722 SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_OUT)), 1723 8, 1724 SCR_MOVE_ABS (1) ^ SCR_ILG_OUT, 1725 NADDR (scratch), 1726 SCR_JUMPR ^ IFFALSE (IF (SCR_ILG_IN)), 1727 8, 1728 SCR_MOVE_ABS (1) ^ SCR_ILG_IN, 1729 NADDR (scratch), 1730 SCR_JUMP, 1731 PADDR (dispatch), 1732 1733 }/*-------------------------< NO_DATA >--------------------*/,{ 1734 /* 1735 ** The target wants to tranfer too much data 1736 ** or in the wrong direction. 1737 ** Remember that in extended error. 1738 */ 1739 SCR_LOAD_REG (scratcha, XE_EXTRA_DATA), 1740 0, 1741 SCR_COPY (1), 1742 RADDR (scratcha), 1743 NADDR (xerr_st), 1744 /* 1745 ** Discard one data byte, if required. 1746 */ 1747 SCR_JUMPR ^ IFFALSE (WHEN (SCR_DATA_OUT)), 1748 8, 1749 SCR_MOVE_ABS (1) ^ SCR_DATA_OUT, 1750 NADDR (scratch), 1751 SCR_JUMPR ^ IFFALSE (IF (SCR_DATA_IN)), 1752 8, 1753 SCR_MOVE_ABS (1) ^ SCR_DATA_IN, 1754 NADDR (scratch), 1755 /* 1756 ** .. and repeat as required. 1757 */ 1758 SCR_CALL, 1759 PADDR (dispatch), 1760 SCR_JUMP, 1761 PADDR (no_data), 1762 }/*-------------------------< CHECKATN >--------------------*/,{ 1763 /* 1764 ** If AAP (bit 1 of scntl0 register) is set 1765 ** and a parity error is detected, 1766 ** the script processor asserts ATN. 1767 ** 1768 ** The target should switch to a MSG_OUT phase 1769 ** to get the message. 1770 */ 1771 SCR_FROM_REG (socl), 1772 0, 1773 SCR_JUMP ^ IFFALSE (MASK (CATN, CATN)), 1774 PADDR (dispatch), 1775 /* 1776 ** count it 1777 */ 1778 SCR_REG_REG (PS_REG, SCR_ADD, 1), 1779 0, 1780 /* 1781 ** Prepare a MSG_INITIATOR_DET_ERR message 1782 ** (initiator detected error). 1783 ** The target should retry the transfer. 1784 */ 1785 SCR_LOAD_REG (scratcha, MSG_INITIATOR_DET_ERR), 1786 0, 1787 SCR_JUMP, 1788 PADDR (setmsg), 1789 1790 }/*-------------------------< COMMAND >--------------------*/,{ 1791 /* 1792 ** If this is not a GETCC transfer ... 1793 */ 1794 SCR_FROM_REG (SS_REG), 1795 0, 1796 /*<<<*/ SCR_JUMPR ^ IFTRUE (DATA (SCSI_STATUS_CHECK_COND)), 1797 28, 1798 /* 1799 ** ... set a timestamp ... 1800 */ 1801 SCR_COPY (sizeof (ticks)), 1802 KVAR (KVAR_TICKS), 1803 NADDR (header.stamp.command), 1804 /* 1805 ** ... and send the command 1806 */ 1807 SCR_MOVE_TBL ^ SCR_COMMAND, 1808 offsetof (struct dsb, cmd), 1809 SCR_JUMP, 1810 PADDR (dispatch), 1811 /* 1812 ** Send the GETCC command 1813 */ 1814 /*>>>*/ SCR_MOVE_TBL ^ SCR_COMMAND, 1815 offsetof (struct dsb, scmd), 1816 SCR_JUMP, 1817 PADDR (dispatch), 1818 1819 }/*-------------------------< STATUS >--------------------*/,{ 1820 /* 1821 ** set the timestamp. 1822 */ 1823 SCR_COPY (sizeof (ticks)), 1824 KVAR (KVAR_TICKS), 1825 NADDR (header.stamp.status), 1826 /* 1827 ** If this is a GETCC transfer, 1828 */ 1829 SCR_FROM_REG (SS_REG), 1830 0, 1831 /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (SCSI_STATUS_CHECK_COND)), 1832 40, 1833 /* 1834 ** get the status 1835 */ 1836 SCR_MOVE_ABS (1) ^ SCR_STATUS, 1837 NADDR (scratch), 1838 /* 1839 ** Save status to scsi_status. 1840 ** Mark as complete. 1841 ** And wait for disconnect. 1842 */ 1843 SCR_TO_REG (SS_REG), 1844 0, 1845 SCR_REG_REG (SS_REG, SCR_OR, SCSI_STATUS_SENSE), 1846 0, 1847 SCR_LOAD_REG (HS_REG, HS_COMPLETE), 1848 0, 1849 SCR_JUMP, 1850 PADDR (checkatn), 1851 /* 1852 ** If it was no GETCC transfer, 1853 ** save the status to scsi_status. 1854 */ 1855 /*>>>*/ SCR_MOVE_ABS (1) ^ SCR_STATUS, 1856 NADDR (scratch), 1857 SCR_TO_REG (SS_REG), 1858 0, 1859 /* 1860 ** if it was no check condition ... 1861 */ 1862 SCR_JUMP ^ IFTRUE (DATA (SCSI_STATUS_CHECK_COND)), 1863 PADDR (checkatn), 1864 /* 1865 ** ... mark as complete. 1866 */ 1867 SCR_LOAD_REG (HS_REG, HS_COMPLETE), 1868 0, 1869 SCR_JUMP, 1870 PADDR (checkatn), 1871 1872 }/*-------------------------< MSG_IN >--------------------*/,{ 1873 /* 1874 ** Get the first byte of the message 1875 ** and save it to SCRATCHA. 1876 ** 1877 ** The script processor doesn't negate the 1878 ** ACK signal after this transfer. 1879 */ 1880 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 1881 NADDR (msgin[0]), 1882 /* 1883 ** Check for message parity error. 1884 */ 1885 SCR_TO_REG (scratcha), 1886 0, 1887 SCR_FROM_REG (socl), 1888 0, 1889 SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)), 1890 PADDRH (msg_parity), 1891 SCR_FROM_REG (scratcha), 1892 0, 1893 /* 1894 ** Parity was ok, handle this message. 1895 */ 1896 SCR_JUMP ^ IFTRUE (DATA (MSG_CMDCOMPLETE)), 1897 PADDR (complete), 1898 SCR_JUMP ^ IFTRUE (DATA (MSG_SAVEDATAPOINTER)), 1899 PADDR (save_dp), 1900 SCR_JUMP ^ IFTRUE (DATA (MSG_RESTOREPOINTERS)), 1901 PADDR (restore_dp), 1902 SCR_JUMP ^ IFTRUE (DATA (MSG_DISCONNECT)), 1903 PADDR (disconnect), 1904 SCR_JUMP ^ IFTRUE (DATA (MSG_EXTENDED)), 1905 PADDRH (msg_extended), 1906 SCR_JUMP ^ IFTRUE (DATA (MSG_NOOP)), 1907 PADDR (clrack), 1908 SCR_JUMP ^ IFTRUE (DATA (MSG_MESSAGE_REJECT)), 1909 PADDRH (msg_reject), 1910 SCR_JUMP ^ IFTRUE (DATA (MSG_IGN_WIDE_RESIDUE)), 1911 PADDRH (msg_ign_residue), 1912 /* 1913 ** Rest of the messages left as 1914 ** an exercise ... 1915 ** 1916 ** Unimplemented messages: 1917 ** fall through to MSG_BAD. 1918 */ 1919 }/*-------------------------< MSG_BAD >------------------*/,{ 1920 /* 1921 ** unimplemented message - reject it. 1922 */ 1923 SCR_INT, 1924 SIR_REJECT_SENT, 1925 SCR_LOAD_REG (scratcha, MSG_MESSAGE_REJECT), 1926 0, 1927 SCR_JUMP, 1928 PADDR (setmsg), 1929 1930 }/*-------------------------< COMPLETE >-----------------*/,{ 1931 /* 1932 ** Complete message. 1933 ** 1934 ** If it's not the get condition code, 1935 ** copy TEMP register to LASTP in header. 1936 */ 1937 SCR_FROM_REG (SS_REG), 1938 0, 1939 /*<<<*/ SCR_JUMPR ^ IFTRUE (MASK (SCSI_STATUS_SENSE, SCSI_STATUS_SENSE)), 1940 12, 1941 SCR_COPY (4), 1942 RADDR (temp), 1943 NADDR (header.lastp), 1944 /*>>>*/ /* 1945 ** When we terminate the cycle by clearing ACK, 1946 ** the target may disconnect immediately. 1947 ** 1948 ** We don't want to be told of an 1949 ** "unexpected disconnect", 1950 ** so we disable this feature. 1951 */ 1952 SCR_REG_REG (scntl2, SCR_AND, 0x7f), 1953 0, 1954 /* 1955 ** Terminate cycle ... 1956 */ 1957 SCR_CLR (SCR_ACK|SCR_ATN), 1958 0, 1959 /* 1960 ** ... and wait for the disconnect. 1961 */ 1962 SCR_WAIT_DISC, 1963 0, 1964 }/*-------------------------< CLEANUP >-------------------*/,{ 1965 /* 1966 ** dsa: Pointer to nccb 1967 ** or xxxxxxFF (no nccb) 1968 ** 1969 ** HS_REG: Host-Status (<>0!) 1970 */ 1971 SCR_FROM_REG (dsa), 1972 0, 1973 SCR_JUMP ^ IFTRUE (DATA (0xff)), 1974 PADDR (signal), 1975 /* 1976 ** dsa is valid. 1977 ** save the status registers 1978 */ 1979 SCR_COPY (4), 1980 RADDR (scr0), 1981 NADDR (header.status), 1982 /* 1983 ** and copy back the header to the nccb. 1984 */ 1985 SCR_COPY_F (4), 1986 RADDR (dsa), 1987 PADDR (cleanup0), 1988 SCR_COPY (sizeof (struct head)), 1989 NADDR (header), 1990 }/*-------------------------< CLEANUP0 >--------------------*/,{ 1991 0, 1992 1993 /* 1994 ** If command resulted in "check condition" 1995 ** status and is not yet completed, 1996 ** try to get the condition code. 1997 */ 1998 SCR_FROM_REG (HS_REG), 1999 0, 2000 /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (0, HS_DONEMASK)), 2001 16, 2002 SCR_FROM_REG (SS_REG), 2003 0, 2004 SCR_JUMP ^ IFTRUE (DATA (SCSI_STATUS_CHECK_COND)), 2005 PADDRH(getcc2), 2006 }/*-------------------------< SIGNAL >----------------------*/,{ 2007 /* 2008 ** if status = queue full, 2009 ** reinsert in startqueue and stall queue. 2010 */ 2011 /*>>>*/ SCR_FROM_REG (SS_REG), 2012 0, 2013 SCR_INT ^ IFTRUE (DATA (SCSI_STATUS_QUEUE_FULL)), 2014 SIR_STALL_QUEUE, 2015 /* 2016 ** And make the DSA register invalid. 2017 */ 2018 SCR_LOAD_REG (dsa, 0xff), /* invalid */ 2019 0, 2020 /* 2021 ** if job completed ... 2022 */ 2023 SCR_FROM_REG (HS_REG), 2024 0, 2025 /* 2026 ** ... signal completion to the host 2027 */ 2028 SCR_INT_FLY ^ IFFALSE (MASK (0, HS_DONEMASK)), 2029 0, 2030 /* 2031 ** Auf zu neuen Schandtaten! 2032 */ 2033 SCR_JUMP, 2034 PADDR(start), 2035 2036 }/*-------------------------< SAVE_DP >------------------*/,{ 2037 /* 2038 ** SAVE_DP message: 2039 ** Copy TEMP register to SAVEP in header. 2040 */ 2041 SCR_COPY (4), 2042 RADDR (temp), 2043 NADDR (header.savep), 2044 SCR_JUMP, 2045 PADDR (clrack), 2046 }/*-------------------------< RESTORE_DP >---------------*/,{ 2047 /* 2048 ** RESTORE_DP message: 2049 ** Copy SAVEP in header to TEMP register. 2050 */ 2051 SCR_COPY (4), 2052 NADDR (header.savep), 2053 RADDR (temp), 2054 SCR_JUMP, 2055 PADDR (clrack), 2056 2057 }/*-------------------------< DISCONNECT >---------------*/,{ 2058 /* 2059 ** If QUIRK_AUTOSAVE is set, 2060 ** do an "save pointer" operation. 2061 */ 2062 SCR_FROM_REG (QU_REG), 2063 0, 2064 /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (QUIRK_AUTOSAVE, QUIRK_AUTOSAVE)), 2065 12, 2066 /* 2067 ** like SAVE_DP message: 2068 ** Copy TEMP register to SAVEP in header. 2069 */ 2070 SCR_COPY (4), 2071 RADDR (temp), 2072 NADDR (header.savep), 2073 /*>>>*/ /* 2074 ** Check if temp==savep or temp==goalp: 2075 ** if not, log a missing save pointer message. 2076 ** In fact, it's a comparison mod 256. 2077 ** 2078 ** Hmmm, I hadn't thought that I would be urged to 2079 ** write this kind of ugly self modifying code. 2080 ** 2081 ** It's unbelievable, but the ncr53c8xx isn't able 2082 ** to subtract one register from another. 2083 */ 2084 SCR_FROM_REG (temp), 2085 0, 2086 /* 2087 ** You are not expected to understand this .. 2088 ** 2089 ** CAUTION: only little endian architectures supported! XXX 2090 */ 2091 SCR_COPY_F (1), 2092 NADDR (header.savep), 2093 PADDR (disconnect0), 2094 }/*-------------------------< DISCONNECT0 >--------------*/,{ 2095 /*<<<*/ SCR_JUMPR ^ IFTRUE (DATA (1)), 2096 20, 2097 /* 2098 ** neither this 2099 */ 2100 SCR_COPY_F (1), 2101 NADDR (header.goalp), 2102 PADDR (disconnect1), 2103 }/*-------------------------< DISCONNECT1 >--------------*/,{ 2104 SCR_INT ^ IFFALSE (DATA (1)), 2105 SIR_MISSING_SAVE, 2106 /*>>>*/ 2107 2108 /* 2109 ** DISCONNECTing ... 2110 ** 2111 ** disable the "unexpected disconnect" feature, 2112 ** and remove the ACK signal. 2113 */ 2114 SCR_REG_REG (scntl2, SCR_AND, 0x7f), 2115 0, 2116 SCR_CLR (SCR_ACK|SCR_ATN), 2117 0, 2118 /* 2119 ** Wait for the disconnect. 2120 */ 2121 SCR_WAIT_DISC, 2122 0, 2123 /* 2124 ** Profiling: 2125 ** Set a time stamp, 2126 ** and count the disconnects. 2127 */ 2128 SCR_COPY (sizeof (ticks)), 2129 KVAR (KVAR_TICKS), 2130 NADDR (header.stamp.disconnect), 2131 SCR_COPY (4), 2132 NADDR (disc_phys), 2133 RADDR (temp), 2134 SCR_REG_REG (temp, SCR_ADD, 0x01), 2135 0, 2136 SCR_COPY (4), 2137 RADDR (temp), 2138 NADDR (disc_phys), 2139 /* 2140 ** Status is: DISCONNECTED. 2141 */ 2142 SCR_LOAD_REG (HS_REG, HS_DISCONNECT), 2143 0, 2144 SCR_JUMP, 2145 PADDR (cleanup), 2146 2147 }/*-------------------------< MSG_OUT >-------------------*/,{ 2148 /* 2149 ** The target requests a message. 2150 */ 2151 SCR_MOVE_ABS (1) ^ SCR_MSG_OUT, 2152 NADDR (msgout), 2153 SCR_COPY (1), 2154 RADDR (sfbr), 2155 NADDR (lastmsg), 2156 /* 2157 ** If it was no ABORT message ... 2158 */ 2159 SCR_JUMP ^ IFTRUE (DATA (MSG_ABORT)), 2160 PADDRH (msg_out_abort), 2161 /* 2162 ** ... wait for the next phase 2163 ** if it's a message out, send it again, ... 2164 */ 2165 SCR_JUMP ^ IFTRUE (WHEN (SCR_MSG_OUT)), 2166 PADDR (msg_out), 2167 }/*-------------------------< MSG_OUT_DONE >--------------*/,{ 2168 /* 2169 ** ... else clear the message ... 2170 */ 2171 SCR_LOAD_REG (scratcha, MSG_NOOP), 2172 0, 2173 SCR_COPY (4), 2174 RADDR (scratcha), 2175 NADDR (msgout), 2176 /* 2177 ** ... and process the next phase 2178 */ 2179 SCR_JUMP, 2180 PADDR (dispatch), 2181 2182 }/*------------------------< BADGETCC >---------------------*/,{ 2183 /* 2184 ** If SIGP was set, clear it and try again. 2185 */ 2186 SCR_FROM_REG (ctest2), 2187 0, 2188 SCR_JUMP ^ IFTRUE (MASK (CSIGP,CSIGP)), 2189 PADDRH (getcc2), 2190 SCR_INT, 2191 SIR_SENSE_FAILED, 2192 }/*-------------------------< RESELECT >--------------------*/,{ 2193 /* 2194 ** This NOP will be patched with LED OFF 2195 ** SCR_REG_REG (gpreg, SCR_OR, 0x01) 2196 */ 2197 SCR_NO_OP, 2198 0, 2199 2200 /* 2201 ** make the DSA invalid. 2202 */ 2203 SCR_LOAD_REG (dsa, 0xff), 2204 0, 2205 SCR_CLR (SCR_TRG), 2206 0, 2207 /* 2208 ** Sleep waiting for a reselection. 2209 ** If SIGP is set, special treatment. 2210 ** 2211 ** Zu allem bereit .. 2212 */ 2213 SCR_WAIT_RESEL, 2214 PADDR(reselect2), 2215 }/*-------------------------< RESELECT1 >--------------------*/,{ 2216 /* 2217 ** This NOP will be patched with LED ON 2218 ** SCR_REG_REG (gpreg, SCR_AND, 0xfe) 2219 */ 2220 SCR_NO_OP, 2221 0, 2222 /* 2223 ** ... zu nichts zu gebrauchen ? 2224 ** 2225 ** load the target id into the SFBR 2226 ** and jump to the control block. 2227 ** 2228 ** Look at the declarations of 2229 ** - struct ncb 2230 ** - struct tcb 2231 ** - struct lcb 2232 ** - struct nccb 2233 ** to understand what's going on. 2234 */ 2235 SCR_REG_SFBR (ssid, SCR_AND, 0x8F), 2236 0, 2237 SCR_TO_REG (sdid), 2238 0, 2239 SCR_JUMP, 2240 NADDR (jump_tcb), 2241 }/*-------------------------< RESELECT2 >-------------------*/,{ 2242 /* 2243 ** This NOP will be patched with LED ON 2244 ** SCR_REG_REG (gpreg, SCR_AND, 0xfe) 2245 */ 2246 SCR_NO_OP, 2247 0, 2248 /* 2249 ** If it's not connected :( 2250 ** -> interrupted by SIGP bit. 2251 ** Jump to start. 2252 */ 2253 SCR_FROM_REG (ctest2), 2254 0, 2255 SCR_JUMP ^ IFTRUE (MASK (CSIGP,CSIGP)), 2256 PADDR (start), 2257 SCR_JUMP, 2258 PADDR (reselect), 2259 2260 }/*-------------------------< RESEL_TMP >-------------------*/,{ 2261 /* 2262 ** The return address in TEMP 2263 ** is in fact the data structure address, 2264 ** so copy it to the DSA register. 2265 */ 2266 SCR_COPY (4), 2267 RADDR (temp), 2268 RADDR (dsa), 2269 SCR_JUMP, 2270 PADDR (prepare), 2271 2272 }/*-------------------------< RESEL_LUN >-------------------*/,{ 2273 /* 2274 ** come back to this point 2275 ** to get an IDENTIFY message 2276 ** Wait for a msg_in phase. 2277 */ 2278 /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)), 2279 48, 2280 /* 2281 ** message phase 2282 ** It's not a sony, it's a trick: 2283 ** read the data without acknowledging it. 2284 */ 2285 SCR_FROM_REG (sbdl), 2286 0, 2287 /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (MSG_IDENTIFYFLAG, 0x98)), 2288 32, 2289 /* 2290 ** It WAS an Identify message. 2291 ** get it and ack it! 2292 */ 2293 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 2294 NADDR (msgin), 2295 SCR_CLR (SCR_ACK), 2296 0, 2297 /* 2298 ** Mask out the lun. 2299 */ 2300 SCR_REG_REG (sfbr, SCR_AND, 0x07), 2301 0, 2302 SCR_RETURN, 2303 0, 2304 /* 2305 ** No message phase or no IDENTIFY message: 2306 ** return 0. 2307 */ 2308 /*>>>*/ SCR_LOAD_SFBR (0), 2309 0, 2310 SCR_RETURN, 2311 0, 2312 2313 }/*-------------------------< RESEL_TAG >-------------------*/,{ 2314 /* 2315 ** come back to this point 2316 ** to get a SIMPLE_TAG message 2317 ** Wait for a MSG_IN phase. 2318 */ 2319 /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)), 2320 64, 2321 /* 2322 ** message phase 2323 ** It's a trick - read the data 2324 ** without acknowledging it. 2325 */ 2326 SCR_FROM_REG (sbdl), 2327 0, 2328 /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (MSG_SIMPLE_Q_TAG)), 2329 48, 2330 /* 2331 ** It WAS a SIMPLE_TAG message. 2332 ** get it and ack it! 2333 */ 2334 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 2335 NADDR (msgin), 2336 SCR_CLR (SCR_ACK), 2337 0, 2338 /* 2339 ** Wait for the second byte (the tag) 2340 */ 2341 /*<<<*/ SCR_JUMPR ^ IFFALSE (WHEN (SCR_MSG_IN)), 2342 24, 2343 /* 2344 ** Get it and ack it! 2345 */ 2346 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 2347 NADDR (msgin), 2348 SCR_CLR (SCR_ACK|SCR_CARRY), 2349 0, 2350 SCR_RETURN, 2351 0, 2352 /* 2353 ** No message phase or no SIMPLE_TAG message 2354 ** or no second byte: return 0. 2355 */ 2356 /*>>>*/ SCR_LOAD_SFBR (0), 2357 0, 2358 SCR_SET (SCR_CARRY), 2359 0, 2360 SCR_RETURN, 2361 0, 2362 2363 }/*-------------------------< DATA_IN >--------------------*/,{ 2364 /* 2365 ** Because the size depends on the 2366 ** #define MAX_SCATTER parameter, 2367 ** it is filled in at runtime. 2368 ** 2369 ** SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_IN)), 2370 ** PADDR (no_data), 2371 ** SCR_COPY (sizeof (ticks)), 2372 ** KVAR (KVAR_TICKS), 2373 ** NADDR (header.stamp.data), 2374 ** SCR_MOVE_TBL ^ SCR_DATA_IN, 2375 ** offsetof (struct dsb, data[ 0]), 2376 ** 2377 ** ##===========< i=1; i<MAX_SCATTER >========= 2378 ** || SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)), 2379 ** || PADDR (checkatn), 2380 ** || SCR_MOVE_TBL ^ SCR_DATA_IN, 2381 ** || offsetof (struct dsb, data[ i]), 2382 ** ##========================================== 2383 ** 2384 ** SCR_CALL, 2385 ** PADDR (checkatn), 2386 ** SCR_JUMP, 2387 ** PADDR (no_data), 2388 */ 2389 0 2390 }/*-------------------------< DATA_OUT >-------------------*/,{ 2391 /* 2392 ** Because the size depends on the 2393 ** #define MAX_SCATTER parameter, 2394 ** it is filled in at runtime. 2395 ** 2396 ** SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_OUT)), 2397 ** PADDR (no_data), 2398 ** SCR_COPY (sizeof (ticks)), 2399 ** KVAR (KVAR_TICKS), 2400 ** NADDR (header.stamp.data), 2401 ** SCR_MOVE_TBL ^ SCR_DATA_OUT, 2402 ** offsetof (struct dsb, data[ 0]), 2403 ** 2404 ** ##===========< i=1; i<MAX_SCATTER >========= 2405 ** || SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT)), 2406 ** || PADDR (dispatch), 2407 ** || SCR_MOVE_TBL ^ SCR_DATA_OUT, 2408 ** || offsetof (struct dsb, data[ i]), 2409 ** ##========================================== 2410 ** 2411 ** SCR_CALL, 2412 ** PADDR (dispatch), 2413 ** SCR_JUMP, 2414 ** PADDR (no_data), 2415 ** 2416 **--------------------------------------------------------- 2417 */ 2418 (u_long)0 2419 2420 }/*--------------------------------------------------------*/ 2421 }; 2422 2423 2424 static struct scripth scripth0 = { 2425 /*-------------------------< TRYLOOP >---------------------*/{ 2426 /* 2427 ** Load an entry of the start queue into dsa 2428 ** and try to start it by jumping to TRYSEL. 2429 ** 2430 ** Because the size depends on the 2431 ** #define MAX_START parameter, it is filled 2432 ** in at runtime. 2433 ** 2434 **----------------------------------------------------------- 2435 ** 2436 ** ##===========< I=0; i<MAX_START >=========== 2437 ** || SCR_COPY (4), 2438 ** || NADDR (squeue[i]), 2439 ** || RADDR (dsa), 2440 ** || SCR_CALL, 2441 ** || PADDR (trysel), 2442 ** ##========================================== 2443 ** 2444 ** SCR_JUMP, 2445 ** PADDRH(tryloop), 2446 ** 2447 **----------------------------------------------------------- 2448 */ 2449 0 2450 }/*-------------------------< MSG_PARITY >---------------*/,{ 2451 /* 2452 ** count it 2453 */ 2454 SCR_REG_REG (PS_REG, SCR_ADD, 0x01), 2455 0, 2456 /* 2457 ** send a "message parity error" message. 2458 */ 2459 SCR_LOAD_REG (scratcha, MSG_PARITY_ERROR), 2460 0, 2461 SCR_JUMP, 2462 PADDR (setmsg), 2463 }/*-------------------------< MSG_MESSAGE_REJECT >---------------*/,{ 2464 /* 2465 ** If a negotiation was in progress, 2466 ** negotiation failed. 2467 */ 2468 SCR_FROM_REG (HS_REG), 2469 0, 2470 SCR_INT ^ IFTRUE (DATA (HS_NEGOTIATE)), 2471 SIR_NEGO_FAILED, 2472 /* 2473 ** else make host log this message 2474 */ 2475 SCR_INT ^ IFFALSE (DATA (HS_NEGOTIATE)), 2476 SIR_REJECT_RECEIVED, 2477 SCR_JUMP, 2478 PADDR (clrack), 2479 2480 }/*-------------------------< MSG_IGN_RESIDUE >----------*/,{ 2481 /* 2482 ** Terminate cycle 2483 */ 2484 SCR_CLR (SCR_ACK), 2485 0, 2486 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)), 2487 PADDR (dispatch), 2488 /* 2489 ** get residue size. 2490 */ 2491 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 2492 NADDR (msgin[1]), 2493 /* 2494 ** Check for message parity error. 2495 */ 2496 SCR_TO_REG (scratcha), 2497 0, 2498 SCR_FROM_REG (socl), 2499 0, 2500 SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)), 2501 PADDRH (msg_parity), 2502 SCR_FROM_REG (scratcha), 2503 0, 2504 /* 2505 ** Size is 0 .. ignore message. 2506 */ 2507 SCR_JUMP ^ IFTRUE (DATA (0)), 2508 PADDR (clrack), 2509 /* 2510 ** Size is not 1 .. have to interrupt. 2511 */ 2512 /*<<<*/ SCR_JUMPR ^ IFFALSE (DATA (1)), 2513 40, 2514 /* 2515 ** Check for residue byte in swide register 2516 */ 2517 SCR_FROM_REG (scntl2), 2518 0, 2519 /*<<<*/ SCR_JUMPR ^ IFFALSE (MASK (WSR, WSR)), 2520 16, 2521 /* 2522 ** There IS data in the swide register. 2523 ** Discard it. 2524 */ 2525 SCR_REG_REG (scntl2, SCR_OR, WSR), 2526 0, 2527 SCR_JUMP, 2528 PADDR (clrack), 2529 /* 2530 ** Load again the size to the sfbr register. 2531 */ 2532 /*>>>*/ SCR_FROM_REG (scratcha), 2533 0, 2534 /*>>>*/ SCR_INT, 2535 SIR_IGN_RESIDUE, 2536 SCR_JUMP, 2537 PADDR (clrack), 2538 2539 }/*-------------------------< MSG_EXTENDED >-------------*/,{ 2540 /* 2541 ** Terminate cycle 2542 */ 2543 SCR_CLR (SCR_ACK), 2544 0, 2545 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)), 2546 PADDR (dispatch), 2547 /* 2548 ** get length. 2549 */ 2550 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 2551 NADDR (msgin[1]), 2552 /* 2553 ** Check for message parity error. 2554 */ 2555 SCR_TO_REG (scratcha), 2556 0, 2557 SCR_FROM_REG (socl), 2558 0, 2559 SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)), 2560 PADDRH (msg_parity), 2561 SCR_FROM_REG (scratcha), 2562 0, 2563 /* 2564 */ 2565 SCR_JUMP ^ IFTRUE (DATA (3)), 2566 PADDRH (msg_ext_3), 2567 SCR_JUMP ^ IFFALSE (DATA (2)), 2568 PADDR (msg_bad), 2569 }/*-------------------------< MSG_EXT_2 >----------------*/,{ 2570 SCR_CLR (SCR_ACK), 2571 0, 2572 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)), 2573 PADDR (dispatch), 2574 /* 2575 ** get extended message code. 2576 */ 2577 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 2578 NADDR (msgin[2]), 2579 /* 2580 ** Check for message parity error. 2581 */ 2582 SCR_TO_REG (scratcha), 2583 0, 2584 SCR_FROM_REG (socl), 2585 0, 2586 SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)), 2587 PADDRH (msg_parity), 2588 SCR_FROM_REG (scratcha), 2589 0, 2590 SCR_JUMP ^ IFTRUE (DATA (MSG_EXT_WDTR)), 2591 PADDRH (msg_wdtr), 2592 /* 2593 ** unknown extended message 2594 */ 2595 SCR_JUMP, 2596 PADDR (msg_bad) 2597 }/*-------------------------< MSG_WDTR >-----------------*/,{ 2598 SCR_CLR (SCR_ACK), 2599 0, 2600 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)), 2601 PADDR (dispatch), 2602 /* 2603 ** get data bus width 2604 */ 2605 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 2606 NADDR (msgin[3]), 2607 SCR_FROM_REG (socl), 2608 0, 2609 SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)), 2610 PADDRH (msg_parity), 2611 /* 2612 ** let the host do the real work. 2613 */ 2614 SCR_INT, 2615 SIR_NEGO_WIDE, 2616 /* 2617 ** let the target fetch our answer. 2618 */ 2619 SCR_SET (SCR_ATN), 2620 0, 2621 SCR_CLR (SCR_ACK), 2622 0, 2623 2624 SCR_INT ^ IFFALSE (WHEN (SCR_MSG_OUT)), 2625 SIR_NEGO_PROTO, 2626 /* 2627 ** Send the MSG_EXT_WDTR 2628 */ 2629 SCR_MOVE_ABS (4) ^ SCR_MSG_OUT, 2630 NADDR (msgout), 2631 SCR_CLR (SCR_ATN), 2632 0, 2633 SCR_COPY (1), 2634 RADDR (sfbr), 2635 NADDR (lastmsg), 2636 SCR_JUMP, 2637 PADDR (msg_out_done), 2638 2639 }/*-------------------------< MSG_EXT_3 >----------------*/,{ 2640 SCR_CLR (SCR_ACK), 2641 0, 2642 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)), 2643 PADDR (dispatch), 2644 /* 2645 ** get extended message code. 2646 */ 2647 SCR_MOVE_ABS (1) ^ SCR_MSG_IN, 2648 NADDR (msgin[2]), 2649 /* 2650 ** Check for message parity error. 2651 */ 2652 SCR_TO_REG (scratcha), 2653 0, 2654 SCR_FROM_REG (socl), 2655 0, 2656 SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)), 2657 PADDRH (msg_parity), 2658 SCR_FROM_REG (scratcha), 2659 0, 2660 SCR_JUMP ^ IFTRUE (DATA (MSG_EXT_SDTR)), 2661 PADDRH (msg_sdtr), 2662 /* 2663 ** unknown extended message 2664 */ 2665 SCR_JUMP, 2666 PADDR (msg_bad) 2667 2668 }/*-------------------------< MSG_SDTR >-----------------*/,{ 2669 SCR_CLR (SCR_ACK), 2670 0, 2671 SCR_JUMP ^ IFFALSE (WHEN (SCR_MSG_IN)), 2672 PADDR (dispatch), 2673 /* 2674 ** get period and offset 2675 */ 2676 SCR_MOVE_ABS (2) ^ SCR_MSG_IN, 2677 NADDR (msgin[3]), 2678 SCR_FROM_REG (socl), 2679 0, 2680 SCR_JUMP ^ IFTRUE (MASK (CATN, CATN)), 2681 PADDRH (msg_parity), 2682 /* 2683 ** let the host do the real work. 2684 */ 2685 SCR_INT, 2686 SIR_NEGO_SYNC, 2687 /* 2688 ** let the target fetch our answer. 2689 */ 2690 SCR_SET (SCR_ATN), 2691 0, 2692 SCR_CLR (SCR_ACK), 2693 0, 2694 2695 SCR_INT ^ IFFALSE (WHEN (SCR_MSG_OUT)), 2696 SIR_NEGO_PROTO, 2697 /* 2698 ** Send the MSG_EXT_SDTR 2699 */ 2700 SCR_MOVE_ABS (5) ^ SCR_MSG_OUT, 2701 NADDR (msgout), 2702 SCR_CLR (SCR_ATN), 2703 0, 2704 SCR_COPY (1), 2705 RADDR (sfbr), 2706 NADDR (lastmsg), 2707 SCR_JUMP, 2708 PADDR (msg_out_done), 2709 2710 }/*-------------------------< MSG_OUT_ABORT >-------------*/,{ 2711 /* 2712 ** After ABORT message, 2713 ** 2714 ** expect an immediate disconnect, ... 2715 */ 2716 SCR_REG_REG (scntl2, SCR_AND, 0x7f), 2717 0, 2718 SCR_CLR (SCR_ACK|SCR_ATN), 2719 0, 2720 SCR_WAIT_DISC, 2721 0, 2722 /* 2723 ** ... and set the status to "ABORTED" 2724 */ 2725 SCR_LOAD_REG (HS_REG, HS_ABORTED), 2726 0, 2727 SCR_JUMP, 2728 PADDR (cleanup), 2729 2730 }/*-------------------------< GETCC >-----------------------*/,{ 2731 /* 2732 ** The ncr doesn't have an indirect load 2733 ** or store command. So we have to 2734 ** copy part of the control block to a 2735 ** fixed place, where we can modify it. 2736 ** 2737 ** We patch the address part of a COPY command 2738 ** with the address of the dsa register ... 2739 */ 2740 SCR_COPY_F (4), 2741 RADDR (dsa), 2742 PADDRH (getcc1), 2743 /* 2744 ** ... then we do the actual copy. 2745 */ 2746 SCR_COPY (sizeof (struct head)), 2747 }/*-------------------------< GETCC1 >----------------------*/,{ 2748 0, 2749 NADDR (header), 2750 /* 2751 ** Initialize the status registers 2752 */ 2753 SCR_COPY (4), 2754 NADDR (header.status), 2755 RADDR (scr0), 2756 }/*-------------------------< GETCC2 >----------------------*/,{ 2757 /* 2758 ** Get the condition code from a target. 2759 ** 2760 ** DSA points to a data structure. 2761 ** Set TEMP to the script location 2762 ** that receives the condition code. 2763 ** 2764 ** Because there is no script command 2765 ** to load a longword into a register, 2766 ** we use a CALL command. 2767 */ 2768 /*<<<*/ SCR_CALLR, 2769 24, 2770 /* 2771 ** Get the condition code. 2772 */ 2773 SCR_MOVE_TBL ^ SCR_DATA_IN, 2774 offsetof (struct dsb, sense), 2775 /* 2776 ** No data phase may follow! 2777 */ 2778 SCR_CALL, 2779 PADDR (checkatn), 2780 SCR_JUMP, 2781 PADDR (no_data), 2782 /*>>>*/ 2783 2784 /* 2785 ** The CALL jumps to this point. 2786 ** Prepare for a RESTORE_POINTER message. 2787 ** Save the TEMP register into the saved pointer. 2788 */ 2789 SCR_COPY (4), 2790 RADDR (temp), 2791 NADDR (header.savep), 2792 /* 2793 ** Load scratcha, because in case of a selection timeout, 2794 ** the host will expect a new value for startpos in 2795 ** the scratcha register. 2796 */ 2797 SCR_COPY (4), 2798 PADDR (startpos), 2799 RADDR (scratcha), 2800 #ifdef NCR_GETCC_WITHMSG 2801 /* 2802 ** If QUIRK_NOMSG is set, select without ATN. 2803 ** and don't send a message. 2804 */ 2805 SCR_FROM_REG (QU_REG), 2806 0, 2807 SCR_JUMP ^ IFTRUE (MASK (QUIRK_NOMSG, QUIRK_NOMSG)), 2808 PADDRH(getcc3), 2809 /* 2810 ** Then try to connect to the target. 2811 ** If we are reselected, special treatment 2812 ** of the current job is required before 2813 ** accepting the reselection. 2814 */ 2815 SCR_SEL_TBL_ATN ^ offsetof (struct dsb, select), 2816 PADDR(badgetcc), 2817 /* 2818 ** Send the IDENTIFY message. 2819 ** In case of short transfer, remove ATN. 2820 */ 2821 SCR_MOVE_TBL ^ SCR_MSG_OUT, 2822 offsetof (struct dsb, smsg2), 2823 SCR_CLR (SCR_ATN), 2824 0, 2825 /* 2826 ** save the first byte of the message. 2827 */ 2828 SCR_COPY (1), 2829 RADDR (sfbr), 2830 NADDR (lastmsg), 2831 SCR_JUMP, 2832 PADDR (prepare2), 2833 2834 #endif 2835 }/*-------------------------< GETCC3 >----------------------*/,{ 2836 /* 2837 ** Try to connect to the target. 2838 ** If we are reselected, special treatment 2839 ** of the current job is required before 2840 ** accepting the reselection. 2841 ** 2842 ** Silly target won't accept a message. 2843 ** Select without ATN. 2844 */ 2845 SCR_SEL_TBL ^ offsetof (struct dsb, select), 2846 PADDR(badgetcc), 2847 /* 2848 ** Force error if selection timeout 2849 */ 2850 SCR_JUMPR ^ IFTRUE (WHEN (SCR_MSG_IN)), 2851 0, 2852 /* 2853 ** don't negotiate. 2854 */ 2855 SCR_JUMP, 2856 PADDR (prepare2), 2857 }/*-------------------------< ABORTTAG >-------------------*/,{ 2858 /* 2859 ** Abort a bad reselection. 2860 ** Set the message to ABORT vs. ABORT_TAG 2861 */ 2862 SCR_LOAD_REG (scratcha, MSG_ABORT_TAG), 2863 0, 2864 SCR_JUMPR ^ IFFALSE (CARRYSET), 2865 8, 2866 }/*-------------------------< ABORT >----------------------*/,{ 2867 SCR_LOAD_REG (scratcha, MSG_ABORT), 2868 0, 2869 SCR_COPY (1), 2870 RADDR (scratcha), 2871 NADDR (msgout), 2872 SCR_SET (SCR_ATN), 2873 0, 2874 SCR_CLR (SCR_ACK), 2875 0, 2876 /* 2877 ** and send it. 2878 ** we expect an immediate disconnect 2879 */ 2880 SCR_REG_REG (scntl2, SCR_AND, 0x7f), 2881 0, 2882 SCR_MOVE_ABS (1) ^ SCR_MSG_OUT, 2883 NADDR (msgout), 2884 SCR_COPY (1), 2885 RADDR (sfbr), 2886 NADDR (lastmsg), 2887 SCR_CLR (SCR_ACK|SCR_ATN), 2888 0, 2889 SCR_WAIT_DISC, 2890 0, 2891 SCR_JUMP, 2892 PADDR (start), 2893 }/*-------------------------< SNOOPTEST >-------------------*/,{ 2894 /* 2895 ** Read the variable. 2896 */ 2897 SCR_COPY (4), 2898 KVAR (KVAR_NCR_CACHE), 2899 RADDR (scratcha), 2900 /* 2901 ** Write the variable. 2902 */ 2903 SCR_COPY (4), 2904 RADDR (temp), 2905 KVAR (KVAR_NCR_CACHE), 2906 /* 2907 ** Read back the variable. 2908 */ 2909 SCR_COPY (4), 2910 KVAR (KVAR_NCR_CACHE), 2911 RADDR (temp), 2912 }/*-------------------------< SNOOPEND >-------------------*/,{ 2913 /* 2914 ** And stop. 2915 */ 2916 SCR_INT, 2917 99, 2918 }/*--------------------------------------------------------*/ 2919 }; 2920 2921 2922 /*========================================================== 2923 ** 2924 ** 2925 ** Fill in #define dependent parts of the script 2926 ** 2927 ** 2928 **========================================================== 2929 */ 2930 2931 void ncr_script_fill (struct script * scr, struct scripth * scrh) 2932 { 2933 int i; 2934 ncrcmd *p; 2935 2936 p = scrh->tryloop; 2937 for (i=0; i<MAX_START; i++) { 2938 *p++ =SCR_COPY (4); 2939 *p++ =NADDR (squeue[i]); 2940 *p++ =RADDR (dsa); 2941 *p++ =SCR_CALL; 2942 *p++ =PADDR (trysel); 2943 }; 2944 *p++ =SCR_JUMP; 2945 *p++ =PADDRH(tryloop); 2946 2947 assert ((char *)p == (char *)&scrh->tryloop + sizeof (scrh->tryloop)); 2948 2949 p = scr->data_in; 2950 2951 *p++ =SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_IN)); 2952 *p++ =PADDR (no_data); 2953 *p++ =SCR_COPY (sizeof (ticks)); 2954 *p++ =(ncrcmd) KVAR (KVAR_TICKS); 2955 *p++ =NADDR (header.stamp.data); 2956 *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN; 2957 *p++ =offsetof (struct dsb, data[ 0]); 2958 2959 for (i=1; i<MAX_SCATTER; i++) { 2960 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_IN)); 2961 *p++ =PADDR (checkatn); 2962 *p++ =SCR_MOVE_TBL ^ SCR_DATA_IN; 2963 *p++ =offsetof (struct dsb, data[i]); 2964 }; 2965 2966 *p++ =SCR_CALL; 2967 *p++ =PADDR (checkatn); 2968 *p++ =SCR_JUMP; 2969 *p++ =PADDR (no_data); 2970 2971 assert ((char *)p == (char *)&scr->data_in + sizeof (scr->data_in)); 2972 2973 p = scr->data_out; 2974 2975 *p++ =SCR_JUMP ^ IFFALSE (WHEN (SCR_DATA_OUT)); 2976 *p++ =PADDR (no_data); 2977 *p++ =SCR_COPY (sizeof (ticks)); 2978 *p++ =(ncrcmd) KVAR (KVAR_TICKS); 2979 *p++ =NADDR (header.stamp.data); 2980 *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT; 2981 *p++ =offsetof (struct dsb, data[ 0]); 2982 2983 for (i=1; i<MAX_SCATTER; i++) { 2984 *p++ =SCR_CALL ^ IFFALSE (WHEN (SCR_DATA_OUT)); 2985 *p++ =PADDR (dispatch); 2986 *p++ =SCR_MOVE_TBL ^ SCR_DATA_OUT; 2987 *p++ =offsetof (struct dsb, data[i]); 2988 }; 2989 2990 *p++ =SCR_CALL; 2991 *p++ =PADDR (dispatch); 2992 *p++ =SCR_JUMP; 2993 *p++ =PADDR (no_data); 2994 2995 assert ((char *)p == (char *)&scr->data_out + sizeof (scr->data_out)); 2996 } 2997 2998 /*========================================================== 2999 ** 3000 ** 3001 ** Copy and rebind a script. 3002 ** 3003 ** 3004 **========================================================== 3005 */ 3006 3007 static void ncr_script_copy_and_bind (ncb_p np, ncrcmd *src, ncrcmd *dst, int len) 3008 { 3009 ncrcmd opcode, new, old, tmp1, tmp2; 3010 ncrcmd *start, *end; 3011 int relocs, offset; 3012 3013 start = src; 3014 end = src + len/4; 3015 offset = 0; 3016 3017 while (src < end) { 3018 3019 opcode = *src++; 3020 WRITESCRIPT_OFF(dst, offset, opcode); 3021 offset += 4; 3022 3023 /* 3024 ** If we forget to change the length 3025 ** in struct script, a field will be 3026 ** padded with 0. This is an illegal 3027 ** command. 3028 */ 3029 3030 if (opcode == 0) { 3031 printf ("%s: ERROR0 IN SCRIPT at %d.\n", 3032 ncr_name(np), (int) (src-start-1)); 3033 DELAY (1000000); 3034 }; 3035 3036 if (DEBUG_FLAGS & DEBUG_SCRIPT) 3037 printf ("%p: <%x>\n", 3038 (src-1), (unsigned)opcode); 3039 3040 /* 3041 ** We don't have to decode ALL commands 3042 */ 3043 switch (opcode >> 28) { 3044 3045 case 0xc: 3046 /* 3047 ** COPY has TWO arguments. 3048 */ 3049 relocs = 2; 3050 tmp1 = src[0]; 3051 if ((tmp1 & RELOC_MASK) == RELOC_KVAR) 3052 tmp1 = 0; 3053 tmp2 = src[1]; 3054 if ((tmp2 & RELOC_MASK) == RELOC_KVAR) 3055 tmp2 = 0; 3056 if ((tmp1 ^ tmp2) & 3) { 3057 printf ("%s: ERROR1 IN SCRIPT at %d.\n", 3058 ncr_name(np), (int) (src-start-1)); 3059 DELAY (1000000); 3060 } 3061 /* 3062 ** If PREFETCH feature not enabled, remove 3063 ** the NO FLUSH bit if present. 3064 */ 3065 if ((opcode & SCR_NO_FLUSH) && !(np->features&FE_PFEN)) 3066 WRITESCRIPT_OFF(dst, offset - 4, 3067 (opcode & ~SCR_NO_FLUSH)); 3068 break; 3069 3070 case 0x0: 3071 /* 3072 ** MOVE (absolute address) 3073 */ 3074 relocs = 1; 3075 break; 3076 3077 case 0x8: 3078 /* 3079 ** JUMP / CALL 3080 ** dont't relocate if relative :-) 3081 */ 3082 if (opcode & 0x00800000) 3083 relocs = 0; 3084 else 3085 relocs = 1; 3086 break; 3087 3088 case 0x4: 3089 case 0x5: 3090 case 0x6: 3091 case 0x7: 3092 relocs = 1; 3093 break; 3094 3095 default: 3096 relocs = 0; 3097 break; 3098 }; 3099 3100 if (relocs) { 3101 while (relocs--) { 3102 old = *src++; 3103 3104 switch (old & RELOC_MASK) { 3105 case RELOC_REGISTER: 3106 new = (old & ~RELOC_MASK) + rman_get_start(np->reg_res); 3107 break; 3108 case RELOC_LABEL: 3109 new = (old & ~RELOC_MASK) + np->p_script; 3110 break; 3111 case RELOC_LABELH: 3112 new = (old & ~RELOC_MASK) + np->p_scripth; 3113 break; 3114 case RELOC_SOFTC: 3115 new = (old & ~RELOC_MASK) + vtophys(np); 3116 break; 3117 case RELOC_KVAR: 3118 if (((old & ~RELOC_MASK) < 3119 SCRIPT_KVAR_FIRST) || 3120 ((old & ~RELOC_MASK) > 3121 SCRIPT_KVAR_LAST)) 3122 panic("ncr KVAR out of range"); 3123 new = vtophys(script_kvars[old & 3124 ~RELOC_MASK]); 3125 break; 3126 case 0: 3127 /* Don't relocate a 0 address. */ 3128 if (old == 0) { 3129 new = old; 3130 break; 3131 } 3132 /* fall through */ 3133 default: 3134 panic("ncr_script_copy_and_bind: weird relocation %x @ %d\n", old, (int)(src - start)); 3135 break; 3136 } 3137 3138 WRITESCRIPT_OFF(dst, offset, new); 3139 offset += 4; 3140 } 3141 } else { 3142 WRITESCRIPT_OFF(dst, offset, *src++); 3143 offset += 4; 3144 } 3145 3146 }; 3147 } 3148 3149 /*========================================================== 3150 ** 3151 ** 3152 ** Auto configuration. 3153 ** 3154 ** 3155 **========================================================== 3156 */ 3157 3158 #if 0 3159 /*---------------------------------------------------------- 3160 ** 3161 ** Reduce the transfer length to the max value 3162 ** we can transfer safely. 3163 ** 3164 ** Reading a block greater then MAX_SIZE from the 3165 ** raw (character) device exercises a memory leak 3166 ** in the vm subsystem. This is common to ALL devices. 3167 ** We have submitted a description of this bug to 3168 ** <FreeBSD-bugs@freefall.cdrom.com>. 3169 ** It should be fixed in the current release. 3170 ** 3171 **---------------------------------------------------------- 3172 */ 3173 3174 void ncr_min_phys (struct buf *bp) 3175 { 3176 if ((unsigned long)bp->b_bcount > MAX_SIZE) bp->b_bcount = MAX_SIZE; 3177 } 3178 3179 #endif 3180 3181 #if 0 3182 /*---------------------------------------------------------- 3183 ** 3184 ** Maximal number of outstanding requests per target. 3185 ** 3186 **---------------------------------------------------------- 3187 */ 3188 3189 u_int32_t ncr_info (int unit) 3190 { 3191 return (1); /* may be changed later */ 3192 } 3193 3194 #endif 3195 3196 /*---------------------------------------------------------- 3197 ** 3198 ** NCR chip devices table and chip look up function. 3199 ** Features bit are defined in ncrreg.h. Is it the 3200 ** right place? 3201 ** 3202 **---------------------------------------------------------- 3203 */ 3204 typedef struct { 3205 unsigned long device_id; 3206 unsigned short minrevid; 3207 char *name; 3208 unsigned char maxburst; 3209 unsigned char maxoffs; 3210 unsigned char clock_divn; 3211 unsigned int features; 3212 } ncr_chip; 3213 3214 static ncr_chip ncr_chip_table[] = { 3215 {NCR_810_ID, 0x00, "ncr 53c810 fast10 scsi", 4, 8, 4, 3216 FE_ERL} 3217 , 3218 {NCR_810_ID, 0x10, "ncr 53c810a fast10 scsi", 4, 8, 4, 3219 FE_ERL|FE_LDSTR|FE_PFEN|FE_BOF} 3220 , 3221 {NCR_815_ID, 0x00, "ncr 53c815 fast10 scsi", 4, 8, 4, 3222 FE_ERL|FE_BOF} 3223 , 3224 {NCR_820_ID, 0x00, "ncr 53c820 fast10 wide scsi", 4, 8, 4, 3225 FE_WIDE|FE_ERL} 3226 , 3227 {NCR_825_ID, 0x00, "ncr 53c825 fast10 wide scsi", 4, 8, 4, 3228 FE_WIDE|FE_ERL|FE_BOF} 3229 , 3230 {NCR_825_ID, 0x10, "ncr 53c825a fast10 wide scsi", 7, 8, 4, 3231 FE_WIDE|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3232 , 3233 {NCR_860_ID, 0x00, "ncr 53c860 fast20 scsi", 4, 8, 5, 3234 FE_ULTRA|FE_CLK80|FE_CACHE_SET|FE_LDSTR|FE_PFEN} 3235 , 3236 {NCR_875_ID, 0x00, "ncr 53c875 fast20 wide scsi", 7, 16, 5, 3237 FE_WIDE|FE_ULTRA|FE_CLK80|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3238 , 3239 {NCR_875_ID, 0x02, "ncr 53c875 fast20 wide scsi", 7, 16, 5, 3240 FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3241 , 3242 {NCR_875_ID2, 0x00, "ncr 53c875j fast20 wide scsi", 7, 16, 5, 3243 FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3244 , 3245 {NCR_885_ID, 0x00, "ncr 53c885 fast20 wide scsi", 7, 16, 5, 3246 FE_WIDE|FE_ULTRA|FE_DBLR|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3247 , 3248 {NCR_895_ID, 0x00, "ncr 53c895 fast40 wide scsi", 7, 31, 7, 3249 FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3250 , 3251 {NCR_896_ID, 0x00, "ncr 53c896 fast40 wide scsi", 7, 31, 7, 3252 FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3253 , 3254 {NCR_895A_ID, 0x00, "ncr 53c895a fast40 wide scsi", 7, 31, 7, 3255 FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3256 , 3257 {NCR_1510D_ID, 0x00, "ncr 53c1510d fast40 wide scsi", 7, 31, 7, 3258 FE_WIDE|FE_ULTRA2|FE_QUAD|FE_CACHE_SET|FE_DFS|FE_LDSTR|FE_PFEN|FE_RAM} 3259 }; 3260 3261 static int ncr_chip_lookup(u_long device_id, u_char revision_id) 3262 { 3263 int i, found; 3264 3265 found = -1; 3266 for (i = 0; i < sizeof(ncr_chip_table)/sizeof(ncr_chip_table[0]); i++) { 3267 if (device_id == ncr_chip_table[i].device_id && 3268 ncr_chip_table[i].minrevid <= revision_id) { 3269 if (found < 0 || 3270 ncr_chip_table[found].minrevid 3271 < ncr_chip_table[i].minrevid) { 3272 found = i; 3273 } 3274 } 3275 } 3276 return found; 3277 } 3278 3279 /*---------------------------------------------------------- 3280 ** 3281 ** Probe the hostadapter. 3282 ** 3283 **---------------------------------------------------------- 3284 */ 3285 3286 3287 3288 static int ncr_probe (device_t dev) 3289 { 3290 int i; 3291 3292 i = ncr_chip_lookup(pci_get_devid(dev), pci_get_revid(dev)); 3293 if (i >= 0) { 3294 device_set_desc(dev, ncr_chip_table[i].name); 3295 return (-1000); /* Allows to use both ncr and sym */ 3296 } 3297 3298 return (ENXIO); 3299 } 3300 3301 3302 3303 /*========================================================== 3304 ** 3305 ** NCR chip clock divisor table. 3306 ** Divisors are multiplied by 10,000,000 in order to make 3307 ** calculations more simple. 3308 ** 3309 **========================================================== 3310 */ 3311 3312 #define _5M 5000000 3313 static u_long div_10M[] = 3314 {2*_5M, 3*_5M, 4*_5M, 6*_5M, 8*_5M, 12*_5M, 16*_5M}; 3315 3316 /*=============================================================== 3317 ** 3318 ** NCR chips allow burst lengths of 2, 4, 8, 16, 32, 64, 128 3319 ** transfers. 32,64,128 are only supported by 875 and 895 chips. 3320 ** We use log base 2 (burst length) as internal code, with 3321 ** value 0 meaning "burst disabled". 3322 ** 3323 **=============================================================== 3324 */ 3325 3326 /* 3327 * Burst length from burst code. 3328 */ 3329 #define burst_length(bc) (!(bc))? 0 : 1 << (bc) 3330 3331 /* 3332 * Burst code from io register bits. 3333 */ 3334 #define burst_code(dmode, ctest4, ctest5) \ 3335 (ctest4) & 0x80? 0 : (((dmode) & 0xc0) >> 6) + ((ctest5) & 0x04) + 1 3336 3337 /* 3338 * Set initial io register bits from burst code. 3339 */ 3340 static void 3341 ncr_init_burst(ncb_p np, u_char bc) 3342 { 3343 np->rv_ctest4 &= ~0x80; 3344 np->rv_dmode &= ~(0x3 << 6); 3345 np->rv_ctest5 &= ~0x4; 3346 3347 if (!bc) { 3348 np->rv_ctest4 |= 0x80; 3349 } 3350 else { 3351 --bc; 3352 np->rv_dmode |= ((bc & 0x3) << 6); 3353 np->rv_ctest5 |= (bc & 0x4); 3354 } 3355 } 3356 3357 /*========================================================== 3358 ** 3359 ** 3360 ** Auto configuration: attach and init a host adapter. 3361 ** 3362 ** 3363 **========================================================== 3364 */ 3365 3366 3367 static int 3368 ncr_attach (device_t dev) 3369 { 3370 ncb_p np = (struct ncb*) device_get_softc(dev); 3371 u_char rev = 0; 3372 u_long period; 3373 int i, rid; 3374 u_int8_t usrsync; 3375 u_int8_t usrwide; 3376 struct cam_devq *devq; 3377 3378 /* 3379 ** allocate and initialize structures. 3380 */ 3381 3382 np->unit = device_get_unit(dev); 3383 3384 /* 3385 ** Try to map the controller chip to 3386 ** virtual and physical memory. 3387 */ 3388 3389 np->reg_rid = 0x14; 3390 np->reg_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &np->reg_rid, 3391 0, ~0, 1, RF_ACTIVE); 3392 if (!np->reg_res) { 3393 device_printf(dev, "could not map memory\n"); 3394 return ENXIO; 3395 } 3396 3397 /* 3398 ** Make the controller's registers available. 3399 ** Now the INB INW INL OUTB OUTW OUTL macros 3400 ** can be used safely. 3401 */ 3402 3403 np->bst = rman_get_bustag(np->reg_res); 3404 np->bsh = rman_get_bushandle(np->reg_res); 3405 3406 3407 #ifdef NCR_IOMAPPED 3408 /* 3409 ** Try to map the controller chip into iospace. 3410 */ 3411 3412 if (!pci_map_port (config_id, 0x10, &np->port)) 3413 return; 3414 #endif 3415 3416 3417 /* 3418 ** Save some controller register default values 3419 */ 3420 3421 np->rv_scntl3 = INB(nc_scntl3) & 0x77; 3422 np->rv_dmode = INB(nc_dmode) & 0xce; 3423 np->rv_dcntl = INB(nc_dcntl) & 0xa9; 3424 np->rv_ctest3 = INB(nc_ctest3) & 0x01; 3425 np->rv_ctest4 = INB(nc_ctest4) & 0x88; 3426 np->rv_ctest5 = INB(nc_ctest5) & 0x24; 3427 np->rv_gpcntl = INB(nc_gpcntl); 3428 np->rv_stest2 = INB(nc_stest2) & 0x20; 3429 3430 if (bootverbose >= 2) { 3431 printf ("\tBIOS values: SCNTL3:%02x DMODE:%02x DCNTL:%02x\n", 3432 np->rv_scntl3, np->rv_dmode, np->rv_dcntl); 3433 printf ("\t CTEST3:%02x CTEST4:%02x CTEST5:%02x\n", 3434 np->rv_ctest3, np->rv_ctest4, np->rv_ctest5); 3435 } 3436 3437 np->rv_dcntl |= NOCOM; 3438 3439 /* 3440 ** Do chip dependent initialization. 3441 */ 3442 3443 rev = pci_get_revid(dev); 3444 3445 /* 3446 ** Get chip features from chips table. 3447 */ 3448 i = ncr_chip_lookup(pci_get_devid(dev), rev); 3449 3450 if (i >= 0) { 3451 np->maxburst = ncr_chip_table[i].maxburst; 3452 np->maxoffs = ncr_chip_table[i].maxoffs; 3453 np->clock_divn = ncr_chip_table[i].clock_divn; 3454 np->features = ncr_chip_table[i].features; 3455 } else { /* Should'nt happen if probe() is ok */ 3456 np->maxburst = 4; 3457 np->maxoffs = 8; 3458 np->clock_divn = 4; 3459 np->features = FE_ERL; 3460 } 3461 3462 np->maxwide = np->features & FE_WIDE ? 1 : 0; 3463 np->clock_khz = np->features & FE_CLK80 ? 80000 : 40000; 3464 if (np->features & FE_QUAD) np->multiplier = 4; 3465 else if (np->features & FE_DBLR) np->multiplier = 2; 3466 else np->multiplier = 1; 3467 3468 /* 3469 ** Get the frequency of the chip's clock. 3470 ** Find the right value for scntl3. 3471 */ 3472 if (np->features & (FE_ULTRA|FE_ULTRA2)) 3473 ncr_getclock(np, np->multiplier); 3474 3475 #ifdef NCR_TEKRAM_EEPROM 3476 if (bootverbose) { 3477 printf ("%s: Tekram EEPROM read %s\n", 3478 ncr_name(np), 3479 read_tekram_eeprom (np, NULL) ? 3480 "succeeded" : "failed"); 3481 } 3482 #endif /* NCR_TEKRAM_EEPROM */ 3483 3484 /* 3485 * If scntl3 != 0, we assume BIOS is present. 3486 */ 3487 if (np->rv_scntl3) 3488 np->features |= FE_BIOS; 3489 3490 /* 3491 * Divisor to be used for async (timer pre-scaler). 3492 */ 3493 i = np->clock_divn - 1; 3494 while (i >= 0) { 3495 --i; 3496 if (10ul * SCSI_NCR_MIN_ASYNC * np->clock_khz > div_10M[i]) { 3497 ++i; 3498 break; 3499 } 3500 } 3501 np->rv_scntl3 = i+1; 3502 3503 /* 3504 * Minimum synchronous period factor supported by the chip. 3505 * Btw, 'period' is in tenths of nanoseconds. 3506 */ 3507 3508 period = (4 * div_10M[0] + np->clock_khz - 1) / np->clock_khz; 3509 if (period <= 250) np->minsync = 10; 3510 else if (period <= 303) np->minsync = 11; 3511 else if (period <= 500) np->minsync = 12; 3512 else np->minsync = (period + 40 - 1) / 40; 3513 3514 /* 3515 * Check against chip SCSI standard support (SCSI-2,ULTRA,ULTRA2). 3516 */ 3517 3518 if (np->minsync < 25 && !(np->features & (FE_ULTRA|FE_ULTRA2))) 3519 np->minsync = 25; 3520 else if (np->minsync < 12 && !(np->features & FE_ULTRA2)) 3521 np->minsync = 12; 3522 3523 /* 3524 * Maximum synchronous period factor supported by the chip. 3525 */ 3526 3527 period = (11 * div_10M[np->clock_divn - 1]) / (4 * np->clock_khz); 3528 np->maxsync = period > 2540 ? 254 : period / 10; 3529 3530 /* 3531 * Now, some features available with Symbios compatible boards. 3532 * LED support through GPIO0 and DIFF support. 3533 */ 3534 3535 #ifdef SCSI_NCR_SYMBIOS_COMPAT 3536 if (!(np->rv_gpcntl & 0x01)) 3537 np->features |= FE_LED0; 3538 #if 0 /* Not safe enough without NVRAM support or user settable option */ 3539 if (!(INB(nc_gpreg) & 0x08)) 3540 np->features |= FE_DIFF; 3541 #endif 3542 #endif /* SCSI_NCR_SYMBIOS_COMPAT */ 3543 3544 /* 3545 * Prepare initial IO registers settings. 3546 * Trust BIOS only if we believe we have one and if we want to. 3547 */ 3548 #ifdef SCSI_NCR_TRUST_BIOS 3549 if (!(np->features & FE_BIOS)) { 3550 #else 3551 if (1) { 3552 #endif 3553 np->rv_dmode = 0; 3554 np->rv_dcntl = NOCOM; 3555 np->rv_ctest3 = 0; 3556 np->rv_ctest4 = MPEE; 3557 np->rv_ctest5 = 0; 3558 np->rv_stest2 = 0; 3559 3560 if (np->features & FE_ERL) 3561 np->rv_dmode |= ERL; /* Enable Read Line */ 3562 if (np->features & FE_BOF) 3563 np->rv_dmode |= BOF; /* Burst Opcode Fetch */ 3564 if (np->features & FE_ERMP) 3565 np->rv_dmode |= ERMP; /* Enable Read Multiple */ 3566 if (np->features & FE_CLSE) 3567 np->rv_dcntl |= CLSE; /* Cache Line Size Enable */ 3568 if (np->features & FE_WRIE) 3569 np->rv_ctest3 |= WRIE; /* Write and Invalidate */ 3570 if (np->features & FE_PFEN) 3571 np->rv_dcntl |= PFEN; /* Prefetch Enable */ 3572 if (np->features & FE_DFS) 3573 np->rv_ctest5 |= DFS; /* Dma Fifo Size */ 3574 if (np->features & FE_DIFF) 3575 np->rv_stest2 |= 0x20; /* Differential mode */ 3576 ncr_init_burst(np, np->maxburst); /* Max dwords burst length */ 3577 } else { 3578 np->maxburst = 3579 burst_code(np->rv_dmode, np->rv_ctest4, np->rv_ctest5); 3580 } 3581 3582 /* 3583 ** Get on-chip SRAM address, if supported 3584 */ 3585 if ((np->features & FE_RAM) && sizeof(struct script) <= 4096) { 3586 np->sram_rid = 0x18; 3587 np->sram_res = bus_alloc_resource(dev, SYS_RES_MEMORY, 3588 &np->sram_rid, 3589 0, ~0, 1, RF_ACTIVE); 3590 } 3591 3592 /* 3593 ** Allocate structure for script relocation. 3594 */ 3595 if (np->sram_res != NULL) { 3596 np->script = NULL; 3597 np->p_script = rman_get_start(np->sram_res); 3598 np->bst2 = rman_get_bustag(np->sram_res); 3599 np->bsh2 = rman_get_bushandle(np->sram_res); 3600 } else if (sizeof (struct script) > PAGE_SIZE) { 3601 np->script = (struct script*) vm_page_alloc_contig 3602 (round_page(sizeof (struct script)), 3603 0, 0xffffffff, PAGE_SIZE); 3604 } else { 3605 np->script = (struct script *) 3606 malloc (sizeof (struct script), M_DEVBUF, M_WAITOK); 3607 } 3608 3609 /* XXX JGibbs - Use contigmalloc */ 3610 if (sizeof (struct scripth) > PAGE_SIZE) { 3611 np->scripth = (struct scripth*) vm_page_alloc_contig 3612 (round_page(sizeof (struct scripth)), 3613 0, 0xffffffff, PAGE_SIZE); 3614 } else 3615 { 3616 np->scripth = (struct scripth *) 3617 malloc (sizeof (struct scripth), M_DEVBUF, M_WAITOK); 3618 } 3619 3620 #ifdef SCSI_NCR_PCI_CONFIG_FIXUP 3621 /* 3622 ** If cache line size is enabled, check PCI config space and 3623 ** try to fix it up if necessary. 3624 */ 3625 #ifdef PCIR_CACHELNSZ /* To be sure that new PCI stuff is present */ 3626 { 3627 u_char cachelnsz = pci_read_config(dev, PCIR_CACHELNSZ, 1); 3628 u_short command = pci_read_config(dev, PCIR_COMMAND, 2); 3629 3630 if (!cachelnsz) { 3631 cachelnsz = 8; 3632 printf("%s: setting PCI cache line size register to %d.\n", 3633 ncr_name(np), (int)cachelnsz); 3634 pci_write_config(dev, PCIR_CACHELNSZ, cachelnsz, 1); 3635 } 3636 3637 if (!(command & (1<<4))) { 3638 command |= (1<<4); 3639 printf("%s: setting PCI command write and invalidate.\n", 3640 ncr_name(np)); 3641 pci_write_config(dev, PCIR_COMMAND, command, 2); 3642 } 3643 } 3644 #endif /* PCIR_CACHELNSZ */ 3645 3646 #endif /* SCSI_NCR_PCI_CONFIG_FIXUP */ 3647 3648 /* Initialize per-target user settings */ 3649 usrsync = 0; 3650 if (SCSI_NCR_DFLT_SYNC) { 3651 usrsync = SCSI_NCR_DFLT_SYNC; 3652 if (usrsync > np->maxsync) 3653 usrsync = np->maxsync; 3654 if (usrsync < np->minsync) 3655 usrsync = np->minsync; 3656 }; 3657 3658 usrwide = (SCSI_NCR_MAX_WIDE); 3659 if (usrwide > np->maxwide) usrwide=np->maxwide; 3660 3661 for (i=0;i<MAX_TARGET;i++) { 3662 tcb_p tp = &np->target[i]; 3663 3664 tp->tinfo.user.period = usrsync; 3665 tp->tinfo.user.offset = usrsync != 0 ? np->maxoffs : 0; 3666 tp->tinfo.user.width = usrwide; 3667 tp->tinfo.disc_tag = NCR_CUR_DISCENB 3668 | NCR_CUR_TAGENB 3669 | NCR_USR_DISCENB 3670 | NCR_USR_TAGENB; 3671 } 3672 3673 /* 3674 ** Bells and whistles ;-) 3675 */ 3676 if (bootverbose) 3677 printf("%s: minsync=%d, maxsync=%d, maxoffs=%d, %d dwords burst, %s dma fifo\n", 3678 ncr_name(np), np->minsync, np->maxsync, np->maxoffs, 3679 burst_length(np->maxburst), 3680 (np->rv_ctest5 & DFS) ? "large" : "normal"); 3681 3682 /* 3683 ** Print some complementary information that can be helpfull. 3684 */ 3685 if (bootverbose) 3686 printf("%s: %s, %s IRQ driver%s\n", 3687 ncr_name(np), 3688 np->rv_stest2 & 0x20 ? "differential" : "single-ended", 3689 np->rv_dcntl & IRQM ? "totem pole" : "open drain", 3690 np->sram_res ? ", using on-chip SRAM" : ""); 3691 3692 /* 3693 ** Patch scripts to physical addresses 3694 */ 3695 ncr_script_fill (&script0, &scripth0); 3696 3697 if (np->script) 3698 np->p_script = vtophys(np->script); 3699 np->p_scripth = vtophys(np->scripth); 3700 3701 ncr_script_copy_and_bind (np, (ncrcmd *) &script0, 3702 (ncrcmd *) np->script, sizeof(struct script)); 3703 3704 ncr_script_copy_and_bind (np, (ncrcmd *) &scripth0, 3705 (ncrcmd *) np->scripth, sizeof(struct scripth)); 3706 3707 /* 3708 ** Patch the script for LED support. 3709 */ 3710 3711 if (np->features & FE_LED0) { 3712 WRITESCRIPT(reselect[0], SCR_REG_REG(gpreg, SCR_OR, 0x01)); 3713 WRITESCRIPT(reselect1[0], SCR_REG_REG(gpreg, SCR_AND, 0xfe)); 3714 WRITESCRIPT(reselect2[0], SCR_REG_REG(gpreg, SCR_AND, 0xfe)); 3715 } 3716 3717 /* 3718 ** init data structure 3719 */ 3720 3721 np->jump_tcb.l_cmd = SCR_JUMP; 3722 np->jump_tcb.l_paddr = NCB_SCRIPTH_PHYS (np, abort); 3723 3724 /* 3725 ** Get SCSI addr of host adapter (set by bios?). 3726 */ 3727 3728 np->myaddr = INB(nc_scid) & 0x07; 3729 if (!np->myaddr) np->myaddr = SCSI_NCR_MYADDR; 3730 3731 #ifdef NCR_DUMP_REG 3732 /* 3733 ** Log the initial register contents 3734 */ 3735 { 3736 int reg; 3737 for (reg=0; reg<256; reg+=4) { 3738 if (reg%16==0) printf ("reg[%2x]", reg); 3739 printf (" %08x", (int)pci_conf_read (config_id, reg)); 3740 if (reg%16==12) printf ("\n"); 3741 } 3742 } 3743 #endif /* NCR_DUMP_REG */ 3744 3745 /* 3746 ** Reset chip. 3747 */ 3748 3749 OUTB (nc_istat, SRST); 3750 DELAY (1000); 3751 OUTB (nc_istat, 0 ); 3752 3753 3754 /* 3755 ** Now check the cache handling of the pci chipset. 3756 */ 3757 3758 if (ncr_snooptest (np)) { 3759 printf ("CACHE INCORRECTLY CONFIGURED.\n"); 3760 return EINVAL; 3761 }; 3762 3763 /* 3764 ** Install the interrupt handler. 3765 */ 3766 3767 rid = 0; 3768 np->irq_res = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, 0, ~0, 1, 3769 RF_SHAREABLE | RF_ACTIVE); 3770 if (np->irq_res == NULL) { 3771 device_printf(dev, 3772 "interruptless mode: reduced performance.\n"); 3773 } else { 3774 bus_setup_intr(dev, np->irq_res, INTR_TYPE_CAM, 3775 ncr_intr, np, &np->irq_handle); 3776 } 3777 3778 /* 3779 ** Create the device queue. We only allow MAX_START-1 concurrent 3780 ** transactions so we can be sure to have one element free in our 3781 ** start queue to reset to the idle loop. 3782 */ 3783 devq = cam_simq_alloc(MAX_START - 1); 3784 if (devq == NULL) 3785 return ENOMEM; 3786 3787 /* 3788 ** Now tell the generic SCSI layer 3789 ** about our bus. 3790 */ 3791 np->sim = cam_sim_alloc(ncr_action, ncr_poll, "ncr", np, np->unit, 3792 1, MAX_TAGS, devq); 3793 if (np->sim == NULL) { 3794 cam_simq_free(devq); 3795 return ENOMEM; 3796 } 3797 3798 3799 if (xpt_bus_register(np->sim, 0) != CAM_SUCCESS) { 3800 cam_sim_free(np->sim, /*free_devq*/ TRUE); 3801 return ENOMEM; 3802 } 3803 3804 if (xpt_create_path(&np->path, /*periph*/NULL, 3805 cam_sim_path(np->sim), CAM_TARGET_WILDCARD, 3806 CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 3807 xpt_bus_deregister(cam_sim_path(np->sim)); 3808 cam_sim_free(np->sim, /*free_devq*/TRUE); 3809 return ENOMEM; 3810 } 3811 3812 /* 3813 ** start the timeout daemon 3814 */ 3815 ncr_timeout (np); 3816 np->lasttime=0; 3817 3818 return 0; 3819 } 3820 3821 /*========================================================== 3822 ** 3823 ** 3824 ** Process pending device interrupts. 3825 ** 3826 ** 3827 **========================================================== 3828 */ 3829 3830 static void 3831 ncr_intr(vnp) 3832 void *vnp; 3833 { 3834 ncb_p np = vnp; 3835 int oldspl = splcam(); 3836 3837 if (DEBUG_FLAGS & DEBUG_TINY) printf ("["); 3838 3839 if (INB(nc_istat) & (INTF|SIP|DIP)) { 3840 /* 3841 ** Repeat until no outstanding ints 3842 */ 3843 do { 3844 ncr_exception (np); 3845 } while (INB(nc_istat) & (INTF|SIP|DIP)); 3846 3847 np->ticks = 100; 3848 }; 3849 3850 if (DEBUG_FLAGS & DEBUG_TINY) printf ("]\n"); 3851 3852 splx (oldspl); 3853 } 3854 3855 /*========================================================== 3856 ** 3857 ** 3858 ** Start execution of a SCSI command. 3859 ** This is called from the generic SCSI driver. 3860 ** 3861 ** 3862 **========================================================== 3863 */ 3864 3865 static void 3866 ncr_action (struct cam_sim *sim, union ccb *ccb) 3867 { 3868 ncb_p np; 3869 3870 np = (ncb_p) cam_sim_softc(sim); 3871 3872 switch (ccb->ccb_h.func_code) { 3873 /* Common cases first */ 3874 case XPT_SCSI_IO: /* Execute the requested I/O operation */ 3875 { 3876 nccb_p cp; 3877 lcb_p lp; 3878 tcb_p tp; 3879 int oldspl; 3880 struct ccb_scsiio *csio; 3881 u_int8_t *msgptr; 3882 u_int msglen; 3883 u_int msglen2; 3884 int segments; 3885 u_int8_t nego; 3886 u_int8_t idmsg; 3887 u_int8_t qidx; 3888 3889 tp = &np->target[ccb->ccb_h.target_id]; 3890 csio = &ccb->csio; 3891 3892 oldspl = splcam(); 3893 3894 /* 3895 * Last time we need to check if this CCB needs to 3896 * be aborted. 3897 */ 3898 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) { 3899 xpt_done(ccb); 3900 splx(oldspl); 3901 return; 3902 } 3903 ccb->ccb_h.status |= CAM_SIM_QUEUED; 3904 3905 /*--------------------------------------------------- 3906 ** 3907 ** Assign an nccb / bind ccb 3908 ** 3909 **---------------------------------------------------- 3910 */ 3911 cp = ncr_get_nccb (np, ccb->ccb_h.target_id, 3912 ccb->ccb_h.target_lun); 3913 if (cp == NULL) { 3914 /* XXX JGibbs - Freeze SIMQ */ 3915 ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 3916 xpt_done(ccb); 3917 return; 3918 }; 3919 3920 cp->ccb = ccb; 3921 3922 /*--------------------------------------------------- 3923 ** 3924 ** timestamp 3925 ** 3926 **---------------------------------------------------- 3927 */ 3928 /* 3929 ** XXX JGibbs - Isn't this expensive 3930 ** enough to be conditionalized?? 3931 */ 3932 3933 bzero (&cp->phys.header.stamp, sizeof (struct tstamp)); 3934 cp->phys.header.stamp.start = ticks; 3935 3936 nego = 0; 3937 if (tp->nego_cp == NULL) { 3938 3939 if (tp->tinfo.current.width 3940 != tp->tinfo.goal.width) { 3941 tp->nego_cp = cp; 3942 nego = NS_WIDE; 3943 } else if ((tp->tinfo.current.period 3944 != tp->tinfo.goal.period) 3945 || (tp->tinfo.current.offset 3946 != tp->tinfo.goal.offset)) { 3947 tp->nego_cp = cp; 3948 nego = NS_SYNC; 3949 }; 3950 }; 3951 3952 /*--------------------------------------------------- 3953 ** 3954 ** choose a new tag ... 3955 ** 3956 **---------------------------------------------------- 3957 */ 3958 lp = tp->lp[ccb->ccb_h.target_lun]; 3959 3960 if ((ccb->ccb_h.flags & CAM_TAG_ACTION_VALID) != 0 3961 && (ccb->csio.tag_action != CAM_TAG_ACTION_NONE) 3962 && (nego == 0)) { 3963 /* 3964 ** assign a tag to this nccb 3965 */ 3966 while (!cp->tag) { 3967 nccb_p cp2 = lp->next_nccb; 3968 lp->lasttag = lp->lasttag % 255 + 1; 3969 while (cp2 && cp2->tag != lp->lasttag) 3970 cp2 = cp2->next_nccb; 3971 if (cp2) continue; 3972 cp->tag=lp->lasttag; 3973 if (DEBUG_FLAGS & DEBUG_TAGS) { 3974 PRINT_ADDR(ccb); 3975 printf ("using tag #%d.\n", cp->tag); 3976 }; 3977 }; 3978 } else { 3979 cp->tag=0; 3980 }; 3981 3982 /*---------------------------------------------------- 3983 ** 3984 ** Build the identify / tag / sdtr message 3985 ** 3986 **---------------------------------------------------- 3987 */ 3988 idmsg = MSG_IDENTIFYFLAG | ccb->ccb_h.target_lun; 3989 if (tp->tinfo.disc_tag & NCR_CUR_DISCENB) 3990 idmsg |= MSG_IDENTIFY_DISCFLAG; 3991 3992 msgptr = cp->scsi_smsg; 3993 msglen = 0; 3994 msgptr[msglen++] = idmsg; 3995 3996 if (cp->tag) { 3997 msgptr[msglen++] = ccb->csio.tag_action; 3998 msgptr[msglen++] = cp->tag; 3999 } 4000 4001 switch (nego) { 4002 case NS_SYNC: 4003 msgptr[msglen++] = MSG_EXTENDED; 4004 msgptr[msglen++] = MSG_EXT_SDTR_LEN; 4005 msgptr[msglen++] = MSG_EXT_SDTR; 4006 msgptr[msglen++] = tp->tinfo.goal.period; 4007 msgptr[msglen++] = tp->tinfo.goal.offset;; 4008 if (DEBUG_FLAGS & DEBUG_NEGO) { 4009 PRINT_ADDR(ccb); 4010 printf ("sync msgout: "); 4011 ncr_show_msg (&cp->scsi_smsg [msglen-5]); 4012 printf (".\n"); 4013 }; 4014 break; 4015 case NS_WIDE: 4016 msgptr[msglen++] = MSG_EXTENDED; 4017 msgptr[msglen++] = MSG_EXT_WDTR_LEN; 4018 msgptr[msglen++] = MSG_EXT_WDTR; 4019 msgptr[msglen++] = tp->tinfo.goal.width; 4020 if (DEBUG_FLAGS & DEBUG_NEGO) { 4021 PRINT_ADDR(ccb); 4022 printf ("wide msgout: "); 4023 ncr_show_msg (&cp->scsi_smsg [msglen-4]); 4024 printf (".\n"); 4025 }; 4026 break; 4027 }; 4028 4029 /*---------------------------------------------------- 4030 ** 4031 ** Build the identify message for getcc. 4032 ** 4033 **---------------------------------------------------- 4034 */ 4035 4036 cp->scsi_smsg2 [0] = idmsg; 4037 msglen2 = 1; 4038 4039 /*---------------------------------------------------- 4040 ** 4041 ** Build the data descriptors 4042 ** 4043 **---------------------------------------------------- 4044 */ 4045 4046 /* XXX JGibbs - Handle other types of I/O */ 4047 if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) { 4048 segments = ncr_scatter(&cp->phys, 4049 (vm_offset_t)csio->data_ptr, 4050 (vm_size_t)csio->dxfer_len); 4051 4052 if (segments < 0) { 4053 ccb->ccb_h.status = CAM_REQ_TOO_BIG; 4054 ncr_free_nccb(np, cp); 4055 splx(oldspl); 4056 xpt_done(ccb); 4057 return; 4058 } 4059 if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) { 4060 cp->phys.header.savep = NCB_SCRIPT_PHYS (np, data_in); 4061 cp->phys.header.goalp = cp->phys.header.savep +20 +segments*16; 4062 } else { /* CAM_DIR_OUT */ 4063 cp->phys.header.savep = NCB_SCRIPT_PHYS (np, data_out); 4064 cp->phys.header.goalp = cp->phys.header.savep +20 +segments*16; 4065 } 4066 } else { 4067 cp->phys.header.savep = NCB_SCRIPT_PHYS (np, no_data); 4068 cp->phys.header.goalp = cp->phys.header.savep; 4069 } 4070 4071 cp->phys.header.lastp = cp->phys.header.savep; 4072 4073 4074 /*---------------------------------------------------- 4075 ** 4076 ** fill in nccb 4077 ** 4078 **---------------------------------------------------- 4079 ** 4080 ** 4081 ** physical -> virtual backlink 4082 ** Generic SCSI command 4083 */ 4084 cp->phys.header.cp = cp; 4085 /* 4086 ** Startqueue 4087 */ 4088 cp->phys.header.launch.l_paddr = NCB_SCRIPT_PHYS (np, select); 4089 cp->phys.header.launch.l_cmd = SCR_JUMP; 4090 /* 4091 ** select 4092 */ 4093 cp->phys.select.sel_id = ccb->ccb_h.target_id; 4094 cp->phys.select.sel_scntl3 = tp->tinfo.wval; 4095 cp->phys.select.sel_sxfer = tp->tinfo.sval; 4096 /* 4097 ** message 4098 */ 4099 cp->phys.smsg.addr = CCB_PHYS (cp, scsi_smsg); 4100 cp->phys.smsg.size = msglen; 4101 4102 cp->phys.smsg2.addr = CCB_PHYS (cp, scsi_smsg2); 4103 cp->phys.smsg2.size = msglen2; 4104 /* 4105 ** command 4106 */ 4107 /* XXX JGibbs - Support other command types */ 4108 cp->phys.cmd.addr = vtophys (csio->cdb_io.cdb_bytes); 4109 cp->phys.cmd.size = csio->cdb_len; 4110 /* 4111 ** sense command 4112 */ 4113 cp->phys.scmd.addr = CCB_PHYS (cp, sensecmd); 4114 cp->phys.scmd.size = 6; 4115 /* 4116 ** patch requested size into sense command 4117 */ 4118 cp->sensecmd[0] = 0x03; 4119 cp->sensecmd[1] = ccb->ccb_h.target_lun << 5; 4120 cp->sensecmd[4] = sizeof(struct scsi_sense_data); 4121 cp->sensecmd[4] = csio->sense_len; 4122 /* 4123 ** sense data 4124 */ 4125 cp->phys.sense.addr = vtophys (&csio->sense_data); 4126 cp->phys.sense.size = csio->sense_len; 4127 /* 4128 ** status 4129 */ 4130 cp->actualquirks = QUIRK_NOMSG; 4131 cp->host_status = nego ? HS_NEGOTIATE : HS_BUSY; 4132 cp->s_status = SCSI_STATUS_ILLEGAL; 4133 cp->parity_status = 0; 4134 4135 cp->xerr_status = XE_OK; 4136 cp->sync_status = tp->tinfo.sval; 4137 cp->nego_status = nego; 4138 cp->wide_status = tp->tinfo.wval; 4139 4140 /*---------------------------------------------------- 4141 ** 4142 ** Critical region: start this job. 4143 ** 4144 **---------------------------------------------------- 4145 */ 4146 4147 /* 4148 ** reselect pattern and activate this job. 4149 */ 4150 4151 cp->jump_nccb.l_cmd = (SCR_JUMP ^ IFFALSE (DATA (cp->tag))); 4152 cp->tlimit = time_second 4153 + ccb->ccb_h.timeout / 1000 + 2; 4154 cp->magic = CCB_MAGIC; 4155 4156 /* 4157 ** insert into start queue. 4158 */ 4159 4160 qidx = np->squeueput + 1; 4161 if (qidx >= MAX_START) qidx=0; 4162 np->squeue [qidx ] = NCB_SCRIPT_PHYS (np, idle); 4163 np->squeue [np->squeueput] = CCB_PHYS (cp, phys); 4164 np->squeueput = qidx; 4165 4166 if(DEBUG_FLAGS & DEBUG_QUEUE) 4167 printf("%s: queuepos=%d tryoffset=%d.\n", 4168 ncr_name (np), np->squeueput, 4169 (unsigned)(READSCRIPT(startpos[0]) - 4170 (NCB_SCRIPTH_PHYS (np, tryloop)))); 4171 4172 /* 4173 ** Script processor may be waiting for reselect. 4174 ** Wake it up. 4175 */ 4176 OUTB (nc_istat, SIGP); 4177 4178 /* 4179 ** and reenable interrupts 4180 */ 4181 splx (oldspl); 4182 break; 4183 } 4184 case XPT_RESET_DEV: /* Bus Device Reset the specified SCSI device */ 4185 case XPT_EN_LUN: /* Enable LUN as a target */ 4186 case XPT_TARGET_IO: /* Execute target I/O request */ 4187 case XPT_ACCEPT_TARGET_IO: /* Accept Host Target Mode CDB */ 4188 case XPT_CONT_TARGET_IO: /* Continue Host Target I/O Connection*/ 4189 case XPT_ABORT: /* Abort the specified CCB */ 4190 /* XXX Implement */ 4191 ccb->ccb_h.status = CAM_REQ_INVALID; 4192 xpt_done(ccb); 4193 break; 4194 case XPT_SET_TRAN_SETTINGS: 4195 { 4196 struct ccb_trans_settings *cts; 4197 tcb_p tp; 4198 u_int update_type; 4199 int s; 4200 4201 cts = &ccb->cts; 4202 update_type = 0; 4203 if ((cts->flags & CCB_TRANS_CURRENT_SETTINGS) != 0) 4204 update_type |= NCR_TRANS_GOAL; 4205 if ((cts->flags & CCB_TRANS_USER_SETTINGS) != 0) 4206 update_type |= NCR_TRANS_USER; 4207 4208 s = splcam(); 4209 tp = &np->target[ccb->ccb_h.target_id]; 4210 /* Tag and disc enables */ 4211 if ((cts->valid & CCB_TRANS_DISC_VALID) != 0) { 4212 if (update_type & NCR_TRANS_GOAL) { 4213 if ((cts->flags & CCB_TRANS_DISC_ENB) != 0) 4214 tp->tinfo.disc_tag |= NCR_CUR_DISCENB; 4215 else 4216 tp->tinfo.disc_tag &= ~NCR_CUR_DISCENB; 4217 } 4218 4219 if (update_type & NCR_TRANS_USER) { 4220 if ((cts->flags & CCB_TRANS_DISC_ENB) != 0) 4221 tp->tinfo.disc_tag |= NCR_USR_DISCENB; 4222 else 4223 tp->tinfo.disc_tag &= ~NCR_USR_DISCENB; 4224 } 4225 4226 } 4227 4228 if ((cts->valid & CCB_TRANS_TQ_VALID) != 0) { 4229 if (update_type & NCR_TRANS_GOAL) { 4230 if ((cts->flags & CCB_TRANS_TAG_ENB) != 0) 4231 tp->tinfo.disc_tag |= NCR_CUR_TAGENB; 4232 else 4233 tp->tinfo.disc_tag &= ~NCR_CUR_TAGENB; 4234 } 4235 4236 if (update_type & NCR_TRANS_USER) { 4237 if ((cts->flags & CCB_TRANS_TAG_ENB) != 0) 4238 tp->tinfo.disc_tag |= NCR_USR_TAGENB; 4239 else 4240 tp->tinfo.disc_tag &= ~NCR_USR_TAGENB; 4241 } 4242 } 4243 4244 /* Filter bus width and sync negotiation settings */ 4245 if ((cts->valid & CCB_TRANS_BUS_WIDTH_VALID) != 0) { 4246 if (cts->bus_width > np->maxwide) 4247 cts->bus_width = np->maxwide; 4248 } 4249 4250 if (((cts->valid & CCB_TRANS_SYNC_RATE_VALID) != 0) 4251 || ((cts->valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0)) { 4252 if ((cts->valid & CCB_TRANS_SYNC_RATE_VALID) != 0) { 4253 if (cts->sync_period != 0 4254 && (cts->sync_period < np->minsync)) 4255 cts->sync_period = np->minsync; 4256 } 4257 if ((cts->valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0) { 4258 if (cts->sync_offset == 0) 4259 cts->sync_period = 0; 4260 if (cts->sync_offset > np->maxoffs) 4261 cts->sync_offset = np->maxoffs; 4262 } 4263 } 4264 if ((update_type & NCR_TRANS_USER) != 0) { 4265 if ((cts->valid & CCB_TRANS_SYNC_RATE_VALID) != 0) 4266 tp->tinfo.user.period = cts->sync_period; 4267 if ((cts->valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0) 4268 tp->tinfo.user.offset = cts->sync_offset; 4269 if ((cts->valid & CCB_TRANS_BUS_WIDTH_VALID) != 0) 4270 tp->tinfo.user.width = cts->bus_width; 4271 } 4272 if ((update_type & NCR_TRANS_GOAL) != 0) { 4273 if ((cts->valid & CCB_TRANS_SYNC_RATE_VALID) != 0) 4274 tp->tinfo.goal.period = cts->sync_period; 4275 4276 if ((cts->valid & CCB_TRANS_SYNC_OFFSET_VALID) != 0) 4277 tp->tinfo.goal.offset = cts->sync_offset; 4278 4279 if ((cts->valid & CCB_TRANS_BUS_WIDTH_VALID) != 0) 4280 tp->tinfo.goal.width = cts->bus_width; 4281 } 4282 splx(s); 4283 ccb->ccb_h.status = CAM_REQ_CMP; 4284 xpt_done(ccb); 4285 break; 4286 } 4287 case XPT_GET_TRAN_SETTINGS: 4288 /* Get default/user set transfer settings for the target */ 4289 { 4290 struct ccb_trans_settings *cts; 4291 struct ncr_transinfo *tinfo; 4292 tcb_p tp; 4293 int s; 4294 4295 cts = &ccb->cts; 4296 tp = &np->target[ccb->ccb_h.target_id]; 4297 4298 s = splcam(); 4299 if ((cts->flags & CCB_TRANS_CURRENT_SETTINGS) != 0) { 4300 tinfo = &tp->tinfo.current; 4301 if (tp->tinfo.disc_tag & NCR_CUR_DISCENB) 4302 cts->flags |= CCB_TRANS_DISC_ENB; 4303 else 4304 cts->flags &= ~CCB_TRANS_DISC_ENB; 4305 4306 if (tp->tinfo.disc_tag & NCR_CUR_TAGENB) 4307 cts->flags |= CCB_TRANS_TAG_ENB; 4308 else 4309 cts->flags &= ~CCB_TRANS_TAG_ENB; 4310 } else { 4311 tinfo = &tp->tinfo.user; 4312 if (tp->tinfo.disc_tag & NCR_USR_DISCENB) 4313 cts->flags |= CCB_TRANS_DISC_ENB; 4314 else 4315 cts->flags &= ~CCB_TRANS_DISC_ENB; 4316 4317 if (tp->tinfo.disc_tag & NCR_USR_TAGENB) 4318 cts->flags |= CCB_TRANS_TAG_ENB; 4319 else 4320 cts->flags &= ~CCB_TRANS_TAG_ENB; 4321 } 4322 4323 cts->sync_period = tinfo->period; 4324 cts->sync_offset = tinfo->offset; 4325 cts->bus_width = tinfo->width; 4326 4327 splx(s); 4328 4329 cts->valid = CCB_TRANS_SYNC_RATE_VALID 4330 | CCB_TRANS_SYNC_OFFSET_VALID 4331 | CCB_TRANS_BUS_WIDTH_VALID 4332 | CCB_TRANS_DISC_VALID 4333 | CCB_TRANS_TQ_VALID; 4334 4335 ccb->ccb_h.status = CAM_REQ_CMP; 4336 xpt_done(ccb); 4337 break; 4338 } 4339 case XPT_CALC_GEOMETRY: 4340 { 4341 struct ccb_calc_geometry *ccg; 4342 u_int32_t size_mb; 4343 u_int32_t secs_per_cylinder; 4344 int extended; 4345 4346 /* XXX JGibbs - I'm sure the NCR uses a different strategy, 4347 * but it should be able to deal with Adaptec 4348 * geometry too. 4349 */ 4350 extended = 1; 4351 ccg = &ccb->ccg; 4352 size_mb = ccg->volume_size 4353 / ((1024L * 1024L) / ccg->block_size); 4354 4355 if (size_mb > 1024 && extended) { 4356 ccg->heads = 255; 4357 ccg->secs_per_track = 63; 4358 } else { 4359 ccg->heads = 64; 4360 ccg->secs_per_track = 32; 4361 } 4362 secs_per_cylinder = ccg->heads * ccg->secs_per_track; 4363 ccg->cylinders = ccg->volume_size / secs_per_cylinder; 4364 ccb->ccb_h.status = CAM_REQ_CMP; 4365 xpt_done(ccb); 4366 break; 4367 } 4368 case XPT_RESET_BUS: /* Reset the specified SCSI bus */ 4369 { 4370 OUTB (nc_scntl1, CRST); 4371 ccb->ccb_h.status = CAM_REQ_CMP; 4372 DELAY(10000); /* Wait until our interrupt handler sees it */ 4373 xpt_done(ccb); 4374 break; 4375 } 4376 case XPT_TERM_IO: /* Terminate the I/O process */ 4377 /* XXX Implement */ 4378 ccb->ccb_h.status = CAM_REQ_INVALID; 4379 xpt_done(ccb); 4380 break; 4381 case XPT_PATH_INQ: /* Path routing inquiry */ 4382 { 4383 struct ccb_pathinq *cpi = &ccb->cpi; 4384 4385 cpi->version_num = 1; /* XXX??? */ 4386 cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE; 4387 if ((np->features & FE_WIDE) != 0) 4388 cpi->hba_inquiry |= PI_WIDE_16; 4389 cpi->target_sprt = 0; 4390 cpi->hba_misc = 0; 4391 cpi->hba_eng_cnt = 0; 4392 cpi->max_target = (np->features & FE_WIDE) ? 15 : 7; 4393 cpi->max_lun = MAX_LUN - 1; 4394 cpi->initiator_id = np->myaddr; 4395 cpi->bus_id = cam_sim_bus(sim); 4396 cpi->base_transfer_speed = 3300; 4397 strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); 4398 strncpy(cpi->hba_vid, "Symbios", HBA_IDLEN); 4399 strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); 4400 cpi->unit_number = cam_sim_unit(sim); 4401 cpi->ccb_h.status = CAM_REQ_CMP; 4402 xpt_done(ccb); 4403 break; 4404 } 4405 default: 4406 ccb->ccb_h.status = CAM_REQ_INVALID; 4407 xpt_done(ccb); 4408 break; 4409 } 4410 } 4411 4412 /*========================================================== 4413 ** 4414 ** 4415 ** Complete execution of a SCSI command. 4416 ** Signal completion to the generic SCSI driver. 4417 ** 4418 ** 4419 **========================================================== 4420 */ 4421 4422 void 4423 ncr_complete (ncb_p np, nccb_p cp) 4424 { 4425 union ccb *ccb; 4426 tcb_p tp; 4427 lcb_p lp; 4428 4429 /* 4430 ** Sanity check 4431 */ 4432 4433 if (!cp || (cp->magic!=CCB_MAGIC) || !cp->ccb) return; 4434 cp->magic = 1; 4435 cp->tlimit= 0; 4436 4437 /* 4438 ** No Reselect anymore. 4439 */ 4440 cp->jump_nccb.l_cmd = (SCR_JUMP); 4441 4442 /* 4443 ** No starting. 4444 */ 4445 cp->phys.header.launch.l_paddr= NCB_SCRIPT_PHYS (np, idle); 4446 4447 /* 4448 ** timestamp 4449 */ 4450 ncb_profile (np, cp); 4451 4452 if (DEBUG_FLAGS & DEBUG_TINY) 4453 printf ("CCB=%x STAT=%x/%x\n", (int)(intptr_t)cp & 0xfff, 4454 cp->host_status,cp->s_status); 4455 4456 ccb = cp->ccb; 4457 cp->ccb = NULL; 4458 tp = &np->target[ccb->ccb_h.target_id]; 4459 lp = tp->lp[ccb->ccb_h.target_lun]; 4460 4461 /* 4462 ** We do not queue more than 1 nccb per target 4463 ** with negotiation at any time. If this nccb was 4464 ** used for negotiation, clear this info in the tcb. 4465 */ 4466 4467 if (cp == tp->nego_cp) 4468 tp->nego_cp = NULL; 4469 4470 /* 4471 ** Check for parity errors. 4472 */ 4473 /* XXX JGibbs - What about reporting them??? */ 4474 4475 if (cp->parity_status) { 4476 PRINT_ADDR(ccb); 4477 printf ("%d parity error(s), fallback.\n", cp->parity_status); 4478 /* 4479 ** fallback to asynch transfer. 4480 */ 4481 tp->tinfo.goal.period = 0; 4482 tp->tinfo.goal.offset = 0; 4483 }; 4484 4485 /* 4486 ** Check for extended errors. 4487 */ 4488 4489 if (cp->xerr_status != XE_OK) { 4490 PRINT_ADDR(ccb); 4491 switch (cp->xerr_status) { 4492 case XE_EXTRA_DATA: 4493 printf ("extraneous data discarded.\n"); 4494 break; 4495 case XE_BAD_PHASE: 4496 printf ("illegal scsi phase (4/5).\n"); 4497 break; 4498 default: 4499 printf ("extended error %d.\n", cp->xerr_status); 4500 break; 4501 }; 4502 if (cp->host_status==HS_COMPLETE) 4503 cp->host_status = HS_FAIL; 4504 }; 4505 4506 /* 4507 ** Check the status. 4508 */ 4509 if (cp->host_status == HS_COMPLETE) { 4510 4511 if (cp->s_status == SCSI_STATUS_OK) { 4512 4513 /* 4514 ** All went well. 4515 */ 4516 /* XXX JGibbs - Properly calculate residual */ 4517 4518 tp->bytes += ccb->csio.dxfer_len; 4519 tp->transfers ++; 4520 4521 ccb->ccb_h.status = CAM_REQ_CMP; 4522 } else if ((cp->s_status & SCSI_STATUS_SENSE) != 0) { 4523 4524 /* 4525 * XXX Could be TERMIO too. Should record 4526 * original status. 4527 */ 4528 ccb->csio.scsi_status = SCSI_STATUS_CHECK_COND; 4529 cp->s_status &= ~SCSI_STATUS_SENSE; 4530 if (cp->s_status == SCSI_STATUS_OK) { 4531 ccb->ccb_h.status = 4532 CAM_AUTOSNS_VALID|CAM_SCSI_STATUS_ERROR; 4533 } else { 4534 ccb->ccb_h.status = CAM_AUTOSENSE_FAIL; 4535 } 4536 } else { 4537 ccb->ccb_h.status = CAM_SCSI_STATUS_ERROR; 4538 ccb->csio.scsi_status = cp->s_status; 4539 } 4540 4541 4542 } else if (cp->host_status == HS_SEL_TIMEOUT) { 4543 4544 /* 4545 ** Device failed selection 4546 */ 4547 ccb->ccb_h.status = CAM_SEL_TIMEOUT; 4548 4549 } else if (cp->host_status == HS_TIMEOUT) { 4550 4551 /* 4552 ** No response 4553 */ 4554 ccb->ccb_h.status = CAM_CMD_TIMEOUT; 4555 } else if (cp->host_status == HS_STALL) { 4556 ccb->ccb_h.status = CAM_REQUEUE_REQ; 4557 } else { 4558 4559 /* 4560 ** Other protocol messes 4561 */ 4562 PRINT_ADDR(ccb); 4563 printf ("COMMAND FAILED (%x %x) @%p.\n", 4564 cp->host_status, cp->s_status, cp); 4565 4566 ccb->ccb_h.status = CAM_CMD_TIMEOUT; 4567 } 4568 4569 if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 4570 xpt_freeze_devq(ccb->ccb_h.path, /*count*/1); 4571 ccb->ccb_h.status |= CAM_DEV_QFRZN; 4572 } 4573 4574 /* 4575 ** Free this nccb 4576 */ 4577 ncr_free_nccb (np, cp); 4578 4579 /* 4580 ** signal completion to generic driver. 4581 */ 4582 xpt_done (ccb); 4583 } 4584 4585 /*========================================================== 4586 ** 4587 ** 4588 ** Signal all (or one) control block done. 4589 ** 4590 ** 4591 **========================================================== 4592 */ 4593 4594 void 4595 ncr_wakeup (ncb_p np, u_long code) 4596 { 4597 /* 4598 ** Starting at the default nccb and following 4599 ** the links, complete all jobs with a 4600 ** host_status greater than "disconnect". 4601 ** 4602 ** If the "code" parameter is not zero, 4603 ** complete all jobs that are not IDLE. 4604 */ 4605 4606 nccb_p cp = np->link_nccb; 4607 while (cp) { 4608 switch (cp->host_status) { 4609 4610 case HS_IDLE: 4611 break; 4612 4613 case HS_DISCONNECT: 4614 if(DEBUG_FLAGS & DEBUG_TINY) printf ("D"); 4615 /* fall through */ 4616 4617 case HS_BUSY: 4618 case HS_NEGOTIATE: 4619 if (!code) break; 4620 cp->host_status = code; 4621 4622 /* fall through */ 4623 4624 default: 4625 ncr_complete (np, cp); 4626 break; 4627 }; 4628 cp = cp -> link_nccb; 4629 }; 4630 } 4631 4632 static void 4633 ncr_freeze_devq (ncb_p np, struct cam_path *path) 4634 { 4635 nccb_p cp; 4636 int i; 4637 int count; 4638 int firstskip; 4639 /* 4640 ** Starting at the first nccb and following 4641 ** the links, complete all jobs that match 4642 ** the passed in path and are in the start queue. 4643 */ 4644 4645 cp = np->link_nccb; 4646 count = 0; 4647 firstskip = 0; 4648 while (cp) { 4649 switch (cp->host_status) { 4650 4651 case HS_BUSY: 4652 case HS_NEGOTIATE: 4653 if ((cp->phys.header.launch.l_paddr 4654 == NCB_SCRIPT_PHYS (np, select)) 4655 && (xpt_path_comp(path, cp->ccb->ccb_h.path) >= 0)) { 4656 4657 /* Mark for removal from the start queue */ 4658 for (i = 1; i < MAX_START; i++) { 4659 int idx; 4660 4661 idx = np->squeueput - i; 4662 4663 if (idx < 0) 4664 idx = MAX_START + idx; 4665 if (np->squeue[idx] 4666 == CCB_PHYS(cp, phys)) { 4667 np->squeue[idx] = 4668 NCB_SCRIPT_PHYS (np, skip); 4669 if (i > firstskip) 4670 firstskip = i; 4671 break; 4672 } 4673 } 4674 cp->host_status=HS_STALL; 4675 ncr_complete (np, cp); 4676 count++; 4677 } 4678 break; 4679 default: 4680 break; 4681 } 4682 cp = cp->link_nccb; 4683 } 4684 4685 if (count > 0) { 4686 int j; 4687 int bidx; 4688 4689 /* Compress the start queue */ 4690 j = 0; 4691 bidx = np->squeueput; 4692 i = np->squeueput - firstskip; 4693 if (i < 0) 4694 i = MAX_START + i; 4695 for (;;) { 4696 4697 bidx = i - j; 4698 if (bidx < 0) 4699 bidx = MAX_START + bidx; 4700 4701 if (np->squeue[i] == NCB_SCRIPT_PHYS (np, skip)) { 4702 j++; 4703 } else if (j != 0) { 4704 np->squeue[bidx] = np->squeue[i]; 4705 if (np->squeue[bidx] 4706 == NCB_SCRIPT_PHYS(np, idle)) 4707 break; 4708 } 4709 i = (i + 1) % MAX_START; 4710 } 4711 np->squeueput = bidx; 4712 } 4713 } 4714 4715 /*========================================================== 4716 ** 4717 ** 4718 ** Start NCR chip. 4719 ** 4720 ** 4721 **========================================================== 4722 */ 4723 4724 void 4725 ncr_init(ncb_p np, char * msg, u_long code) 4726 { 4727 int i; 4728 4729 /* 4730 ** Reset chip. 4731 */ 4732 4733 OUTB (nc_istat, SRST); 4734 DELAY (1000); 4735 OUTB (nc_istat, 0); 4736 4737 /* 4738 ** Message. 4739 */ 4740 4741 if (msg) printf ("%s: restart (%s).\n", ncr_name (np), msg); 4742 4743 /* 4744 ** Clear Start Queue 4745 */ 4746 4747 for (i=0;i<MAX_START;i++) 4748 np -> squeue [i] = NCB_SCRIPT_PHYS (np, idle); 4749 4750 /* 4751 ** Start at first entry. 4752 */ 4753 4754 np->squeueput = 0; 4755 WRITESCRIPT(startpos[0], NCB_SCRIPTH_PHYS (np, tryloop)); 4756 WRITESCRIPT(start0 [0], SCR_INT ^ IFFALSE (0)); 4757 4758 /* 4759 ** Wakeup all pending jobs. 4760 */ 4761 4762 ncr_wakeup (np, code); 4763 4764 /* 4765 ** Init chip. 4766 */ 4767 4768 OUTB (nc_istat, 0x00 ); /* Remove Reset, abort ... */ 4769 OUTB (nc_scntl0, 0xca ); /* full arb., ena parity, par->ATN */ 4770 OUTB (nc_scntl1, 0x00 ); /* odd parity, and remove CRST!! */ 4771 ncr_selectclock(np, np->rv_scntl3); /* Select SCSI clock */ 4772 OUTB (nc_scid , RRE|np->myaddr);/* host adapter SCSI address */ 4773 OUTW (nc_respid, 1ul<<np->myaddr);/* id to respond to */ 4774 OUTB (nc_istat , SIGP ); /* Signal Process */ 4775 OUTB (nc_dmode , np->rv_dmode); /* XXX modify burstlen ??? */ 4776 OUTB (nc_dcntl , np->rv_dcntl); 4777 OUTB (nc_ctest3, np->rv_ctest3); 4778 OUTB (nc_ctest5, np->rv_ctest5); 4779 OUTB (nc_ctest4, np->rv_ctest4);/* enable master parity checking */ 4780 OUTB (nc_stest2, np->rv_stest2|EXT); /* Extended Sreq/Sack filtering */ 4781 OUTB (nc_stest3, TE ); /* TolerANT enable */ 4782 OUTB (nc_stime0, 0x0b ); /* HTH = disabled, STO = 0.1 sec. */ 4783 4784 if (bootverbose >= 2) { 4785 printf ("\tACTUAL values:SCNTL3:%02x DMODE:%02x DCNTL:%02x\n", 4786 np->rv_scntl3, np->rv_dmode, np->rv_dcntl); 4787 printf ("\t CTEST3:%02x CTEST4:%02x CTEST5:%02x\n", 4788 np->rv_ctest3, np->rv_ctest4, np->rv_ctest5); 4789 } 4790 4791 /* 4792 ** Enable GPIO0 pin for writing if LED support. 4793 */ 4794 4795 if (np->features & FE_LED0) { 4796 OUTOFFB (nc_gpcntl, 0x01); 4797 } 4798 4799 /* 4800 ** Fill in target structure. 4801 */ 4802 for (i=0;i<MAX_TARGET;i++) { 4803 tcb_p tp = &np->target[i]; 4804 4805 tp->tinfo.sval = 0; 4806 tp->tinfo.wval = np->rv_scntl3; 4807 4808 tp->tinfo.current.period = 0; 4809 tp->tinfo.current.offset = 0; 4810 tp->tinfo.current.width = MSG_EXT_WDTR_BUS_8_BIT; 4811 } 4812 4813 /* 4814 ** enable ints 4815 */ 4816 4817 OUTW (nc_sien , STO|HTH|MA|SGE|UDC|RST); 4818 OUTB (nc_dien , MDPE|BF|ABRT|SSI|SIR|IID); 4819 4820 /* 4821 ** Start script processor. 4822 */ 4823 4824 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, start)); 4825 4826 /* 4827 * Notify the XPT of the event 4828 */ 4829 if (code == HS_RESET) 4830 xpt_async(AC_BUS_RESET, np->path, NULL); 4831 } 4832 4833 static void 4834 ncr_poll(struct cam_sim *sim) 4835 { 4836 ncr_intr(cam_sim_softc(sim)); 4837 } 4838 4839 4840 /*========================================================== 4841 ** 4842 ** Get clock factor and sync divisor for a given 4843 ** synchronous factor period. 4844 ** Returns the clock factor (in sxfer) and scntl3 4845 ** synchronous divisor field. 4846 ** 4847 **========================================================== 4848 */ 4849 4850 static void ncr_getsync(ncb_p np, u_char sfac, u_char *fakp, u_char *scntl3p) 4851 { 4852 u_long clk = np->clock_khz; /* SCSI clock frequency in kHz */ 4853 int div = np->clock_divn; /* Number of divisors supported */ 4854 u_long fak; /* Sync factor in sxfer */ 4855 u_long per; /* Period in tenths of ns */ 4856 u_long kpc; /* (per * clk) */ 4857 4858 /* 4859 ** Compute the synchronous period in tenths of nano-seconds 4860 */ 4861 if (sfac <= 10) per = 250; 4862 else if (sfac == 11) per = 303; 4863 else if (sfac == 12) per = 500; 4864 else per = 40 * sfac; 4865 4866 /* 4867 ** Look for the greatest clock divisor that allows an 4868 ** input speed faster than the period. 4869 */ 4870 kpc = per * clk; 4871 while (--div >= 0) 4872 if (kpc >= (div_10M[div] * 4)) break; 4873 4874 /* 4875 ** Calculate the lowest clock factor that allows an output 4876 ** speed not faster than the period. 4877 */ 4878 fak = (kpc - 1) / div_10M[div] + 1; 4879 4880 #if 0 /* You can #if 1 if you think this optimization is usefull */ 4881 4882 per = (fak * div_10M[div]) / clk; 4883 4884 /* 4885 ** Why not to try the immediate lower divisor and to choose 4886 ** the one that allows the fastest output speed ? 4887 ** We dont want input speed too much greater than output speed. 4888 */ 4889 if (div >= 1 && fak < 6) { 4890 u_long fak2, per2; 4891 fak2 = (kpc - 1) / div_10M[div-1] + 1; 4892 per2 = (fak2 * div_10M[div-1]) / clk; 4893 if (per2 < per && fak2 <= 6) { 4894 fak = fak2; 4895 per = per2; 4896 --div; 4897 } 4898 } 4899 #endif 4900 4901 if (fak < 4) fak = 4; /* Should never happen, too bad ... */ 4902 4903 /* 4904 ** Compute and return sync parameters for the ncr 4905 */ 4906 *fakp = fak - 4; 4907 *scntl3p = ((div+1) << 4) + (sfac < 25 ? 0x80 : 0); 4908 } 4909 4910 /*========================================================== 4911 ** 4912 ** Switch sync mode for current job and its target 4913 ** 4914 **========================================================== 4915 */ 4916 4917 static void 4918 ncr_setsync(ncb_p np, nccb_p cp, u_char scntl3, u_char sxfer, u_char period) 4919 { 4920 union ccb *ccb; 4921 struct ccb_trans_settings neg; 4922 tcb_p tp; 4923 int div; 4924 u_int target = INB (nc_sdid) & 0x0f; 4925 u_int period_10ns; 4926 4927 assert (cp); 4928 if (!cp) return; 4929 4930 ccb = cp->ccb; 4931 assert (ccb); 4932 if (!ccb) return; 4933 assert (target == ccb->ccb_h.target_id); 4934 4935 tp = &np->target[target]; 4936 4937 if (!scntl3 || !(sxfer & 0x1f)) 4938 scntl3 = np->rv_scntl3; 4939 scntl3 = (scntl3 & 0xf0) | (tp->tinfo.wval & EWS) 4940 | (np->rv_scntl3 & 0x07); 4941 4942 /* 4943 ** Deduce the value of controller sync period from scntl3. 4944 ** period is in tenths of nano-seconds. 4945 */ 4946 4947 div = ((scntl3 >> 4) & 0x7); 4948 if ((sxfer & 0x1f) && div) 4949 period_10ns = 4950 (((sxfer>>5)+4)*div_10M[div-1])/np->clock_khz; 4951 else 4952 period_10ns = 0; 4953 4954 tp->tinfo.goal.period = period; 4955 tp->tinfo.goal.offset = sxfer & 0x1f; 4956 tp->tinfo.current.period = period; 4957 tp->tinfo.current.offset = sxfer & 0x1f; 4958 4959 /* 4960 ** Stop there if sync parameters are unchanged 4961 */ 4962 if (tp->tinfo.sval == sxfer && tp->tinfo.wval == scntl3) return; 4963 tp->tinfo.sval = sxfer; 4964 tp->tinfo.wval = scntl3; 4965 4966 if (sxfer & 0x1f) { 4967 /* 4968 ** Disable extended Sreq/Sack filtering 4969 */ 4970 if (period_10ns <= 2000) OUTOFFB (nc_stest2, EXT); 4971 } 4972 4973 /* 4974 ** Tell the SCSI layer about the 4975 ** new transfer parameters. 4976 */ 4977 neg.sync_period = period; 4978 neg.sync_offset = sxfer & 0x1f; 4979 neg.valid = CCB_TRANS_SYNC_RATE_VALID 4980 | CCB_TRANS_SYNC_OFFSET_VALID; 4981 xpt_setup_ccb(&neg.ccb_h, ccb->ccb_h.path, 4982 /*priority*/1); 4983 xpt_async(AC_TRANSFER_NEG, ccb->ccb_h.path, &neg); 4984 4985 /* 4986 ** set actual value and sync_status 4987 */ 4988 OUTB (nc_sxfer, sxfer); 4989 np->sync_st = sxfer; 4990 OUTB (nc_scntl3, scntl3); 4991 np->wide_st = scntl3; 4992 4993 /* 4994 ** patch ALL nccbs of this target. 4995 */ 4996 for (cp = np->link_nccb; cp; cp = cp->link_nccb) { 4997 if (!cp->ccb) continue; 4998 if (cp->ccb->ccb_h.target_id != target) continue; 4999 cp->sync_status = sxfer; 5000 cp->wide_status = scntl3; 5001 }; 5002 } 5003 5004 /*========================================================== 5005 ** 5006 ** Switch wide mode for current job and its target 5007 ** SCSI specs say: a SCSI device that accepts a WDTR 5008 ** message shall reset the synchronous agreement to 5009 ** asynchronous mode. 5010 ** 5011 **========================================================== 5012 */ 5013 5014 static void ncr_setwide (ncb_p np, nccb_p cp, u_char wide, u_char ack) 5015 { 5016 union ccb *ccb; 5017 struct ccb_trans_settings neg; 5018 u_int target = INB (nc_sdid) & 0x0f; 5019 tcb_p tp; 5020 u_char scntl3; 5021 u_char sxfer; 5022 5023 assert (cp); 5024 if (!cp) return; 5025 5026 ccb = cp->ccb; 5027 assert (ccb); 5028 if (!ccb) return; 5029 assert (target == ccb->ccb_h.target_id); 5030 5031 tp = &np->target[target]; 5032 tp->tinfo.current.width = wide; 5033 tp->tinfo.goal.width = wide; 5034 tp->tinfo.current.period = 0; 5035 tp->tinfo.current.offset = 0; 5036 5037 scntl3 = (tp->tinfo.wval & (~EWS)) | (wide ? EWS : 0); 5038 5039 sxfer = ack ? 0 : tp->tinfo.sval; 5040 5041 /* 5042 ** Stop there if sync/wide parameters are unchanged 5043 */ 5044 if (tp->tinfo.sval == sxfer && tp->tinfo.wval == scntl3) return; 5045 tp->tinfo.sval = sxfer; 5046 tp->tinfo.wval = scntl3; 5047 5048 /* Tell the SCSI layer about the new transfer params */ 5049 neg.bus_width = (scntl3 & EWS) ? MSG_EXT_WDTR_BUS_16_BIT 5050 : MSG_EXT_WDTR_BUS_8_BIT; 5051 neg.sync_period = 0; 5052 neg.sync_offset = 0; 5053 neg.valid = CCB_TRANS_BUS_WIDTH_VALID 5054 | CCB_TRANS_SYNC_RATE_VALID 5055 | CCB_TRANS_SYNC_OFFSET_VALID; 5056 xpt_setup_ccb(&neg.ccb_h, ccb->ccb_h.path, 5057 /*priority*/1); 5058 xpt_async(AC_TRANSFER_NEG, ccb->ccb_h.path, &neg); 5059 5060 /* 5061 ** set actual value and sync_status 5062 */ 5063 OUTB (nc_sxfer, sxfer); 5064 np->sync_st = sxfer; 5065 OUTB (nc_scntl3, scntl3); 5066 np->wide_st = scntl3; 5067 5068 /* 5069 ** patch ALL nccbs of this target. 5070 */ 5071 for (cp = np->link_nccb; cp; cp = cp->link_nccb) { 5072 if (!cp->ccb) continue; 5073 if (cp->ccb->ccb_h.target_id != target) continue; 5074 cp->sync_status = sxfer; 5075 cp->wide_status = scntl3; 5076 }; 5077 } 5078 5079 /*========================================================== 5080 ** 5081 ** 5082 ** ncr timeout handler. 5083 ** 5084 ** 5085 **========================================================== 5086 ** 5087 ** Misused to keep the driver running when 5088 ** interrupts are not configured correctly. 5089 ** 5090 **---------------------------------------------------------- 5091 */ 5092 5093 static void 5094 ncr_timeout (void *arg) 5095 { 5096 ncb_p np = arg; 5097 time_t thistime = time_second; 5098 ticks_t step = np->ticks; 5099 u_long count = 0; 5100 long signed t; 5101 nccb_p cp; 5102 5103 if (np->lasttime != thistime) { 5104 /* 5105 ** block ncr interrupts 5106 */ 5107 int oldspl = splcam(); 5108 np->lasttime = thistime; 5109 5110 /*---------------------------------------------------- 5111 ** 5112 ** handle ncr chip timeouts 5113 ** 5114 ** Assumption: 5115 ** We have a chance to arbitrate for the 5116 ** SCSI bus at least every 10 seconds. 5117 ** 5118 **---------------------------------------------------- 5119 */ 5120 5121 t = thistime - np->heartbeat; 5122 5123 if (t<2) np->latetime=0; else np->latetime++; 5124 5125 if (np->latetime>2) { 5126 /* 5127 ** If there are no requests, the script 5128 ** processor will sleep on SEL_WAIT_RESEL. 5129 ** But we have to check whether it died. 5130 ** Let's try to wake it up. 5131 */ 5132 OUTB (nc_istat, SIGP); 5133 }; 5134 5135 /*---------------------------------------------------- 5136 ** 5137 ** handle nccb timeouts 5138 ** 5139 **---------------------------------------------------- 5140 */ 5141 5142 for (cp=np->link_nccb; cp; cp=cp->link_nccb) { 5143 /* 5144 ** look for timed out nccbs. 5145 */ 5146 if (!cp->host_status) continue; 5147 count++; 5148 if (cp->tlimit > thistime) continue; 5149 5150 /* 5151 ** Disable reselect. 5152 ** Remove it from startqueue. 5153 */ 5154 cp->jump_nccb.l_cmd = (SCR_JUMP); 5155 if (cp->phys.header.launch.l_paddr == 5156 NCB_SCRIPT_PHYS (np, select)) { 5157 printf ("%s: timeout nccb=%p (skip)\n", 5158 ncr_name (np), cp); 5159 cp->phys.header.launch.l_paddr 5160 = NCB_SCRIPT_PHYS (np, skip); 5161 }; 5162 5163 switch (cp->host_status) { 5164 5165 case HS_BUSY: 5166 case HS_NEGOTIATE: 5167 /* fall through */ 5168 case HS_DISCONNECT: 5169 cp->host_status=HS_TIMEOUT; 5170 }; 5171 cp->tag = 0; 5172 5173 /* 5174 ** wakeup this nccb. 5175 */ 5176 ncr_complete (np, cp); 5177 }; 5178 splx (oldspl); 5179 } 5180 5181 np->timeout_ch = 5182 timeout (ncr_timeout, (caddr_t) np, step ? step : 1); 5183 5184 if (INB(nc_istat) & (INTF|SIP|DIP)) { 5185 5186 /* 5187 ** Process pending interrupts. 5188 */ 5189 5190 int oldspl = splcam(); 5191 if (DEBUG_FLAGS & DEBUG_TINY) printf ("{"); 5192 ncr_exception (np); 5193 if (DEBUG_FLAGS & DEBUG_TINY) printf ("}"); 5194 splx (oldspl); 5195 }; 5196 } 5197 5198 /*========================================================== 5199 ** 5200 ** log message for real hard errors 5201 ** 5202 ** "ncr0 targ 0?: ERROR (ds:si) (so-si-sd) (sxfer/scntl3) @ name (dsp:dbc)." 5203 ** " reg: r0 r1 r2 r3 r4 r5 r6 ..... rf." 5204 ** 5205 ** exception register: 5206 ** ds: dstat 5207 ** si: sist 5208 ** 5209 ** SCSI bus lines: 5210 ** so: control lines as driver by NCR. 5211 ** si: control lines as seen by NCR. 5212 ** sd: scsi data lines as seen by NCR. 5213 ** 5214 ** wide/fastmode: 5215 ** sxfer: (see the manual) 5216 ** scntl3: (see the manual) 5217 ** 5218 ** current script command: 5219 ** dsp: script adress (relative to start of script). 5220 ** dbc: first word of script command. 5221 ** 5222 ** First 16 register of the chip: 5223 ** r0..rf 5224 ** 5225 **========================================================== 5226 */ 5227 5228 static void ncr_log_hard_error(ncb_p np, u_short sist, u_char dstat) 5229 { 5230 u_int32_t dsp; 5231 int script_ofs; 5232 int script_size; 5233 char *script_name; 5234 u_char *script_base; 5235 int i; 5236 5237 dsp = INL (nc_dsp); 5238 5239 if (np->p_script < dsp && 5240 dsp <= np->p_script + sizeof(struct script)) { 5241 script_ofs = dsp - np->p_script; 5242 script_size = sizeof(struct script); 5243 script_base = (u_char *) np->script; 5244 script_name = "script"; 5245 } 5246 else if (np->p_scripth < dsp && 5247 dsp <= np->p_scripth + sizeof(struct scripth)) { 5248 script_ofs = dsp - np->p_scripth; 5249 script_size = sizeof(struct scripth); 5250 script_base = (u_char *) np->scripth; 5251 script_name = "scripth"; 5252 } else { 5253 script_ofs = dsp; 5254 script_size = 0; 5255 script_base = 0; 5256 script_name = "mem"; 5257 } 5258 5259 printf ("%s:%d: ERROR (%x:%x) (%x-%x-%x) (%x/%x) @ (%s %x:%08x).\n", 5260 ncr_name (np), (unsigned)INB (nc_sdid)&0x0f, dstat, sist, 5261 (unsigned)INB (nc_socl), (unsigned)INB (nc_sbcl), (unsigned)INB (nc_sbdl), 5262 (unsigned)INB (nc_sxfer),(unsigned)INB (nc_scntl3), script_name, script_ofs, 5263 (unsigned)INL (nc_dbc)); 5264 5265 if (((script_ofs & 3) == 0) && 5266 (unsigned)script_ofs < script_size) { 5267 printf ("%s: script cmd = %08x\n", ncr_name(np), 5268 (int)READSCRIPT_OFF(script_base, script_ofs)); 5269 } 5270 5271 printf ("%s: regdump:", ncr_name(np)); 5272 for (i=0; i<16;i++) 5273 printf (" %02x", (unsigned)INB_OFF(i)); 5274 printf (".\n"); 5275 } 5276 5277 /*========================================================== 5278 ** 5279 ** 5280 ** ncr chip exception handler. 5281 ** 5282 ** 5283 **========================================================== 5284 */ 5285 5286 void ncr_exception (ncb_p np) 5287 { 5288 u_char istat, dstat; 5289 u_short sist; 5290 5291 /* 5292 ** interrupt on the fly ? 5293 */ 5294 while ((istat = INB (nc_istat)) & INTF) { 5295 if (DEBUG_FLAGS & DEBUG_TINY) printf ("F "); 5296 OUTB (nc_istat, INTF); 5297 np->profile.num_fly++; 5298 ncr_wakeup (np, 0); 5299 }; 5300 if (!(istat & (SIP|DIP))) { 5301 return; 5302 } 5303 5304 /* 5305 ** Steinbach's Guideline for Systems Programming: 5306 ** Never test for an error condition you don't know how to handle. 5307 */ 5308 5309 sist = (istat & SIP) ? INW (nc_sist) : 0; 5310 dstat = (istat & DIP) ? INB (nc_dstat) : 0; 5311 np->profile.num_int++; 5312 5313 if (DEBUG_FLAGS & DEBUG_TINY) 5314 printf ("<%d|%x:%x|%x:%x>", 5315 INB(nc_scr0), 5316 dstat,sist, 5317 (unsigned)INL(nc_dsp), 5318 (unsigned)INL(nc_dbc)); 5319 if ((dstat==DFE) && (sist==PAR)) return; 5320 5321 /*========================================================== 5322 ** 5323 ** First the normal cases. 5324 ** 5325 **========================================================== 5326 */ 5327 /*------------------------------------------- 5328 ** SCSI reset 5329 **------------------------------------------- 5330 */ 5331 5332 if (sist & RST) { 5333 ncr_init (np, bootverbose ? "scsi reset" : NULL, HS_RESET); 5334 return; 5335 }; 5336 5337 /*------------------------------------------- 5338 ** selection timeout 5339 ** 5340 ** IID excluded from dstat mask! 5341 ** (chip bug) 5342 **------------------------------------------- 5343 */ 5344 5345 if ((sist & STO) && 5346 !(sist & (GEN|HTH|MA|SGE|UDC|RST|PAR)) && 5347 !(dstat & (MDPE|BF|ABRT|SIR))) { 5348 ncr_int_sto (np); 5349 return; 5350 }; 5351 5352 /*------------------------------------------- 5353 ** Phase mismatch. 5354 **------------------------------------------- 5355 */ 5356 5357 if ((sist & MA) && 5358 !(sist & (STO|GEN|HTH|SGE|UDC|RST|PAR)) && 5359 !(dstat & (MDPE|BF|ABRT|SIR|IID))) { 5360 ncr_int_ma (np, dstat); 5361 return; 5362 }; 5363 5364 /*---------------------------------------- 5365 ** move command with length 0 5366 **---------------------------------------- 5367 */ 5368 5369 if ((dstat & IID) && 5370 !(sist & (STO|GEN|HTH|MA|SGE|UDC|RST|PAR)) && 5371 !(dstat & (MDPE|BF|ABRT|SIR)) && 5372 ((INL(nc_dbc) & 0xf8000000) == SCR_MOVE_TBL)) { 5373 /* 5374 ** Target wants more data than available. 5375 ** The "no_data" script will do it. 5376 */ 5377 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, no_data)); 5378 return; 5379 }; 5380 5381 /*------------------------------------------- 5382 ** Programmed interrupt 5383 **------------------------------------------- 5384 */ 5385 5386 if ((dstat & SIR) && 5387 !(sist & (STO|GEN|HTH|MA|SGE|UDC|RST|PAR)) && 5388 !(dstat & (MDPE|BF|ABRT|IID)) && 5389 (INB(nc_dsps) <= SIR_MAX)) { 5390 ncr_int_sir (np); 5391 return; 5392 }; 5393 5394 /*======================================== 5395 ** log message for real hard errors 5396 **======================================== 5397 */ 5398 5399 ncr_log_hard_error(np, sist, dstat); 5400 5401 /*======================================== 5402 ** do the register dump 5403 **======================================== 5404 */ 5405 5406 if (time_second - np->regtime > 10) { 5407 int i; 5408 np->regtime = time_second; 5409 for (i=0; i<sizeof(np->regdump); i++) 5410 ((volatile char*)&np->regdump)[i] = INB_OFF(i); 5411 np->regdump.nc_dstat = dstat; 5412 np->regdump.nc_sist = sist; 5413 }; 5414 5415 5416 /*---------------------------------------- 5417 ** clean up the dma fifo 5418 **---------------------------------------- 5419 */ 5420 5421 if ( (INB(nc_sstat0) & (ILF|ORF|OLF) ) || 5422 (INB(nc_sstat1) & (FF3210) ) || 5423 (INB(nc_sstat2) & (ILF1|ORF1|OLF1)) || /* wide .. */ 5424 !(dstat & DFE)) { 5425 printf ("%s: have to clear fifos.\n", ncr_name (np)); 5426 OUTB (nc_stest3, TE|CSF); /* clear scsi fifo */ 5427 OUTB (nc_ctest3, np->rv_ctest3 | CLF); 5428 /* clear dma fifo */ 5429 } 5430 5431 /*---------------------------------------- 5432 ** handshake timeout 5433 **---------------------------------------- 5434 */ 5435 5436 if (sist & HTH) { 5437 printf ("%s: handshake timeout\n", ncr_name(np)); 5438 OUTB (nc_scntl1, CRST); 5439 DELAY (1000); 5440 OUTB (nc_scntl1, 0x00); 5441 OUTB (nc_scr0, HS_FAIL); 5442 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, cleanup)); 5443 return; 5444 } 5445 5446 /*---------------------------------------- 5447 ** unexpected disconnect 5448 **---------------------------------------- 5449 */ 5450 5451 if ((sist & UDC) && 5452 !(sist & (STO|GEN|HTH|MA|SGE|RST|PAR)) && 5453 !(dstat & (MDPE|BF|ABRT|SIR|IID))) { 5454 OUTB (nc_scr0, HS_UNEXPECTED); 5455 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, cleanup)); 5456 return; 5457 }; 5458 5459 /*---------------------------------------- 5460 ** cannot disconnect 5461 **---------------------------------------- 5462 */ 5463 5464 if ((dstat & IID) && 5465 !(sist & (STO|GEN|HTH|MA|SGE|UDC|RST|PAR)) && 5466 !(dstat & (MDPE|BF|ABRT|SIR)) && 5467 ((INL(nc_dbc) & 0xf8000000) == SCR_WAIT_DISC)) { 5468 /* 5469 ** Unexpected data cycle while waiting for disconnect. 5470 */ 5471 if (INB(nc_sstat2) & LDSC) { 5472 /* 5473 ** It's an early reconnect. 5474 ** Let's continue ... 5475 */ 5476 OUTB (nc_dcntl, np->rv_dcntl | STD); 5477 /* 5478 ** info message 5479 */ 5480 printf ("%s: INFO: LDSC while IID.\n", 5481 ncr_name (np)); 5482 return; 5483 }; 5484 printf ("%s: target %d doesn't release the bus.\n", 5485 ncr_name (np), INB (nc_sdid)&0x0f); 5486 /* 5487 ** return without restarting the NCR. 5488 ** timeout will do the real work. 5489 */ 5490 return; 5491 }; 5492 5493 /*---------------------------------------- 5494 ** single step 5495 **---------------------------------------- 5496 */ 5497 5498 if ((dstat & SSI) && 5499 !(sist & (STO|GEN|HTH|MA|SGE|UDC|RST|PAR)) && 5500 !(dstat & (MDPE|BF|ABRT|SIR|IID))) { 5501 OUTB (nc_dcntl, np->rv_dcntl | STD); 5502 return; 5503 }; 5504 5505 /* 5506 ** @RECOVER@ HTH, SGE, ABRT. 5507 ** 5508 ** We should try to recover from these interrupts. 5509 ** They may occur if there are problems with synch transfers, or 5510 ** if targets are switched on or off while the driver is running. 5511 */ 5512 5513 if (sist & SGE) { 5514 /* clear scsi offsets */ 5515 OUTB (nc_ctest3, np->rv_ctest3 | CLF); 5516 } 5517 5518 /* 5519 ** Freeze controller to be able to read the messages. 5520 */ 5521 5522 if (DEBUG_FLAGS & DEBUG_FREEZE) { 5523 int i; 5524 unsigned char val; 5525 for (i=0; i<0x60; i++) { 5526 switch (i%16) { 5527 5528 case 0: 5529 printf ("%s: reg[%d0]: ", 5530 ncr_name(np),i/16); 5531 break; 5532 case 4: 5533 case 8: 5534 case 12: 5535 printf (" "); 5536 break; 5537 }; 5538 val = bus_space_read_1(np->bst, np->bsh, i); 5539 printf (" %x%x", val/16, val%16); 5540 if (i%16==15) printf (".\n"); 5541 }; 5542 5543 untimeout (ncr_timeout, (caddr_t) np, np->timeout_ch); 5544 5545 printf ("%s: halted!\n", ncr_name(np)); 5546 /* 5547 ** don't restart controller ... 5548 */ 5549 OUTB (nc_istat, SRST); 5550 return; 5551 }; 5552 5553 #ifdef NCR_FREEZE 5554 /* 5555 ** Freeze system to be able to read the messages. 5556 */ 5557 printf ("ncr: fatal error: system halted - press reset to reboot ..."); 5558 (void) splhigh(); 5559 for (;;); 5560 #endif 5561 5562 /* 5563 ** sorry, have to kill ALL jobs ... 5564 */ 5565 5566 ncr_init (np, "fatal error", HS_FAIL); 5567 } 5568 5569 /*========================================================== 5570 ** 5571 ** ncr chip exception handler for selection timeout 5572 ** 5573 **========================================================== 5574 ** 5575 ** There seems to be a bug in the 53c810. 5576 ** Although a STO-Interrupt is pending, 5577 ** it continues executing script commands. 5578 ** But it will fail and interrupt (IID) on 5579 ** the next instruction where it's looking 5580 ** for a valid phase. 5581 ** 5582 **---------------------------------------------------------- 5583 */ 5584 5585 void ncr_int_sto (ncb_p np) 5586 { 5587 u_long dsa, scratcha, diff; 5588 nccb_p cp; 5589 if (DEBUG_FLAGS & DEBUG_TINY) printf ("T"); 5590 5591 /* 5592 ** look for nccb and set the status. 5593 */ 5594 5595 dsa = INL (nc_dsa); 5596 cp = np->link_nccb; 5597 while (cp && (CCB_PHYS (cp, phys) != dsa)) 5598 cp = cp->link_nccb; 5599 5600 if (cp) { 5601 cp-> host_status = HS_SEL_TIMEOUT; 5602 ncr_complete (np, cp); 5603 }; 5604 5605 /* 5606 ** repair start queue 5607 */ 5608 5609 scratcha = INL (nc_scratcha); 5610 diff = scratcha - NCB_SCRIPTH_PHYS (np, tryloop); 5611 5612 /* assert ((diff <= MAX_START * 20) && !(diff % 20));*/ 5613 5614 if ((diff <= MAX_START * 20) && !(diff % 20)) { 5615 WRITESCRIPT(startpos[0], scratcha); 5616 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, start)); 5617 return; 5618 }; 5619 ncr_init (np, "selection timeout", HS_FAIL); 5620 } 5621 5622 /*========================================================== 5623 ** 5624 ** 5625 ** ncr chip exception handler for phase errors. 5626 ** 5627 ** 5628 **========================================================== 5629 ** 5630 ** We have to construct a new transfer descriptor, 5631 ** to transfer the rest of the current block. 5632 ** 5633 **---------------------------------------------------------- 5634 */ 5635 5636 static void ncr_int_ma (ncb_p np, u_char dstat) 5637 { 5638 u_int32_t dbc; 5639 u_int32_t rest; 5640 u_int32_t dsa; 5641 u_int32_t dsp; 5642 u_int32_t nxtdsp; 5643 volatile void *vdsp_base; 5644 size_t vdsp_off; 5645 u_int32_t oadr, olen; 5646 u_int32_t *tblp, *newcmd; 5647 u_char cmd, sbcl, ss0, ss2, ctest5; 5648 u_short delta; 5649 nccb_p cp; 5650 5651 dsp = INL (nc_dsp); 5652 dsa = INL (nc_dsa); 5653 dbc = INL (nc_dbc); 5654 ss0 = INB (nc_sstat0); 5655 ss2 = INB (nc_sstat2); 5656 sbcl= INB (nc_sbcl); 5657 5658 cmd = dbc >> 24; 5659 rest= dbc & 0xffffff; 5660 5661 ctest5 = (np->rv_ctest5 & DFS) ? INB (nc_ctest5) : 0; 5662 if (ctest5 & DFS) 5663 delta=(((ctest5<<8) | (INB (nc_dfifo) & 0xff)) - rest) & 0x3ff; 5664 else 5665 delta=(INB (nc_dfifo) - rest) & 0x7f; 5666 5667 5668 /* 5669 ** The data in the dma fifo has not been transfered to 5670 ** the target -> add the amount to the rest 5671 ** and clear the data. 5672 ** Check the sstat2 register in case of wide transfer. 5673 */ 5674 5675 if (!(dstat & DFE)) rest += delta; 5676 if (ss0 & OLF) rest++; 5677 if (ss0 & ORF) rest++; 5678 if (INB(nc_scntl3) & EWS) { 5679 if (ss2 & OLF1) rest++; 5680 if (ss2 & ORF1) rest++; 5681 }; 5682 OUTB (nc_ctest3, np->rv_ctest3 | CLF); /* clear dma fifo */ 5683 OUTB (nc_stest3, TE|CSF); /* clear scsi fifo */ 5684 5685 /* 5686 ** locate matching cp 5687 */ 5688 cp = np->link_nccb; 5689 while (cp && (CCB_PHYS (cp, phys) != dsa)) 5690 cp = cp->link_nccb; 5691 5692 if (!cp) { 5693 printf ("%s: SCSI phase error fixup: CCB already dequeued (%p)\n", 5694 ncr_name (np), (void *) np->header.cp); 5695 return; 5696 } 5697 if (cp != np->header.cp) { 5698 printf ("%s: SCSI phase error fixup: CCB address mismatch " 5699 "(%p != %p) np->nccb = %p\n", 5700 ncr_name (np), (void *)cp, (void *)np->header.cp, 5701 (void *)np->link_nccb); 5702 /* return;*/ 5703 } 5704 5705 /* 5706 ** find the interrupted script command, 5707 ** and the address at which to continue. 5708 */ 5709 5710 if (dsp == vtophys (&cp->patch[2])) { 5711 vdsp_base = cp; 5712 vdsp_off = offsetof(struct nccb, patch[0]); 5713 nxtdsp = READSCRIPT_OFF(vdsp_base, vdsp_off + 3*4); 5714 } else if (dsp == vtophys (&cp->patch[6])) { 5715 vdsp_base = cp; 5716 vdsp_off = offsetof(struct nccb, patch[4]); 5717 nxtdsp = READSCRIPT_OFF(vdsp_base, vdsp_off + 3*4); 5718 } else if (dsp > np->p_script && 5719 dsp <= np->p_script + sizeof(struct script)) { 5720 vdsp_base = np->script; 5721 vdsp_off = dsp - np->p_script - 8; 5722 nxtdsp = dsp; 5723 } else { 5724 vdsp_base = np->scripth; 5725 vdsp_off = dsp - np->p_scripth - 8; 5726 nxtdsp = dsp; 5727 }; 5728 5729 /* 5730 ** log the information 5731 */ 5732 if (DEBUG_FLAGS & (DEBUG_TINY|DEBUG_PHASE)) { 5733 printf ("P%x%x ",cmd&7, sbcl&7); 5734 printf ("RL=%d D=%d SS0=%x ", 5735 (unsigned) rest, (unsigned) delta, ss0); 5736 }; 5737 if (DEBUG_FLAGS & DEBUG_PHASE) { 5738 printf ("\nCP=%p CP2=%p DSP=%x NXT=%x VDSP=%p CMD=%x ", 5739 cp, np->header.cp, 5740 dsp, 5741 nxtdsp, (volatile char*)vdsp_base+vdsp_off, cmd); 5742 }; 5743 5744 /* 5745 ** get old startaddress and old length. 5746 */ 5747 5748 oadr = READSCRIPT_OFF(vdsp_base, vdsp_off + 1*4); 5749 5750 if (cmd & 0x10) { /* Table indirect */ 5751 tblp = (u_int32_t *) ((char*) &cp->phys + oadr); 5752 olen = tblp[0]; 5753 oadr = tblp[1]; 5754 } else { 5755 tblp = (u_int32_t *) 0; 5756 olen = READSCRIPT_OFF(vdsp_base, vdsp_off) & 0xffffff; 5757 }; 5758 5759 if (DEBUG_FLAGS & DEBUG_PHASE) { 5760 printf ("OCMD=%x\nTBLP=%p OLEN=%lx OADR=%lx\n", 5761 (unsigned) (READSCRIPT_OFF(vdsp_base, vdsp_off) >> 24), 5762 (void *) tblp, 5763 (u_long) olen, 5764 (u_long) oadr); 5765 }; 5766 5767 /* 5768 ** if old phase not dataphase, leave here. 5769 */ 5770 5771 if (cmd != (READSCRIPT_OFF(vdsp_base, vdsp_off) >> 24)) { 5772 PRINT_ADDR(cp->ccb); 5773 printf ("internal error: cmd=%02x != %02x=(vdsp[0] >> 24)\n", 5774 (unsigned)cmd, 5775 (unsigned)READSCRIPT_OFF(vdsp_base, vdsp_off) >> 24); 5776 5777 return; 5778 } 5779 if (cmd & 0x06) { 5780 PRINT_ADDR(cp->ccb); 5781 printf ("phase change %x-%x %d@%08x resid=%d.\n", 5782 cmd&7, sbcl&7, (unsigned)olen, 5783 (unsigned)oadr, (unsigned)rest); 5784 5785 OUTB (nc_dcntl, np->rv_dcntl | STD); 5786 return; 5787 }; 5788 5789 /* 5790 ** choose the correct patch area. 5791 ** if savep points to one, choose the other. 5792 */ 5793 5794 newcmd = cp->patch; 5795 if (cp->phys.header.savep == vtophys (newcmd)) newcmd+=4; 5796 5797 /* 5798 ** fillin the commands 5799 */ 5800 5801 newcmd[0] = ((cmd & 0x0f) << 24) | rest; 5802 newcmd[1] = oadr + olen - rest; 5803 newcmd[2] = SCR_JUMP; 5804 newcmd[3] = nxtdsp; 5805 5806 if (DEBUG_FLAGS & DEBUG_PHASE) { 5807 PRINT_ADDR(cp->ccb); 5808 printf ("newcmd[%d] %x %x %x %x.\n", 5809 (int)(newcmd - cp->patch), 5810 (unsigned)newcmd[0], 5811 (unsigned)newcmd[1], 5812 (unsigned)newcmd[2], 5813 (unsigned)newcmd[3]); 5814 } 5815 /* 5816 ** fake the return address (to the patch). 5817 ** and restart script processor at dispatcher. 5818 */ 5819 np->profile.num_break++; 5820 OUTL (nc_temp, vtophys (newcmd)); 5821 if ((cmd & 7) == 0) 5822 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, dispatch)); 5823 else 5824 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, checkatn)); 5825 } 5826 5827 /*========================================================== 5828 ** 5829 ** 5830 ** ncr chip exception handler for programmed interrupts. 5831 ** 5832 ** 5833 **========================================================== 5834 */ 5835 5836 static int ncr_show_msg (u_char * msg) 5837 { 5838 u_char i; 5839 printf ("%x",*msg); 5840 if (*msg==MSG_EXTENDED) { 5841 for (i=1;i<8;i++) { 5842 if (i-1>msg[1]) break; 5843 printf ("-%x",msg[i]); 5844 }; 5845 return (i+1); 5846 } else if ((*msg & 0xf0) == 0x20) { 5847 printf ("-%x",msg[1]); 5848 return (2); 5849 }; 5850 return (1); 5851 } 5852 5853 void ncr_int_sir (ncb_p np) 5854 { 5855 u_char scntl3; 5856 u_char chg, ofs, per, fak, wide; 5857 u_char num = INB (nc_dsps); 5858 nccb_p cp=0; 5859 u_long dsa; 5860 u_int target = INB (nc_sdid) & 0x0f; 5861 tcb_p tp = &np->target[target]; 5862 int i; 5863 if (DEBUG_FLAGS & DEBUG_TINY) printf ("I#%d", num); 5864 5865 switch (num) { 5866 case SIR_SENSE_RESTART: 5867 case SIR_STALL_RESTART: 5868 break; 5869 5870 default: 5871 /* 5872 ** lookup the nccb 5873 */ 5874 dsa = INL (nc_dsa); 5875 cp = np->link_nccb; 5876 while (cp && (CCB_PHYS (cp, phys) != dsa)) 5877 cp = cp->link_nccb; 5878 5879 assert (cp); 5880 if (!cp) 5881 goto out; 5882 assert (cp == np->header.cp); 5883 if (cp != np->header.cp) 5884 goto out; 5885 } 5886 5887 switch (num) { 5888 5889 /*-------------------------------------------------------------------- 5890 ** 5891 ** Processing of interrupted getcc selects 5892 ** 5893 **-------------------------------------------------------------------- 5894 */ 5895 5896 case SIR_SENSE_RESTART: 5897 /*------------------------------------------ 5898 ** Script processor is idle. 5899 ** Look for interrupted "check cond" 5900 **------------------------------------------ 5901 */ 5902 5903 if (DEBUG_FLAGS & DEBUG_RESTART) 5904 printf ("%s: int#%d",ncr_name (np),num); 5905 cp = (nccb_p) 0; 5906 for (i=0; i<MAX_TARGET; i++) { 5907 if (DEBUG_FLAGS & DEBUG_RESTART) printf (" t%d", i); 5908 tp = &np->target[i]; 5909 if (DEBUG_FLAGS & DEBUG_RESTART) printf ("+"); 5910 cp = tp->hold_cp; 5911 if (!cp) continue; 5912 if (DEBUG_FLAGS & DEBUG_RESTART) printf ("+"); 5913 if ((cp->host_status==HS_BUSY) && 5914 (cp->s_status==SCSI_STATUS_CHECK_COND)) 5915 break; 5916 if (DEBUG_FLAGS & DEBUG_RESTART) printf ("- (remove)"); 5917 tp->hold_cp = cp = (nccb_p) 0; 5918 }; 5919 5920 if (cp) { 5921 if (DEBUG_FLAGS & DEBUG_RESTART) 5922 printf ("+ restart job ..\n"); 5923 OUTL (nc_dsa, CCB_PHYS (cp, phys)); 5924 OUTL (nc_dsp, NCB_SCRIPTH_PHYS (np, getcc)); 5925 return; 5926 }; 5927 5928 /* 5929 ** no job, resume normal processing 5930 */ 5931 if (DEBUG_FLAGS & DEBUG_RESTART) printf (" -- remove trap\n"); 5932 WRITESCRIPT(start0[0], SCR_INT ^ IFFALSE (0)); 5933 break; 5934 5935 case SIR_SENSE_FAILED: 5936 /*------------------------------------------- 5937 ** While trying to select for 5938 ** getting the condition code, 5939 ** a target reselected us. 5940 **------------------------------------------- 5941 */ 5942 if (DEBUG_FLAGS & DEBUG_RESTART) { 5943 PRINT_ADDR(cp->ccb); 5944 printf ("in getcc reselect by t%d.\n", 5945 INB(nc_ssid) & 0x0f); 5946 } 5947 5948 /* 5949 ** Mark this job 5950 */ 5951 cp->host_status = HS_BUSY; 5952 cp->s_status = SCSI_STATUS_CHECK_COND; 5953 np->target[cp->ccb->ccb_h.target_id].hold_cp = cp; 5954 5955 /* 5956 ** And patch code to restart it. 5957 */ 5958 WRITESCRIPT(start0[0], SCR_INT); 5959 break; 5960 5961 /*----------------------------------------------------------------------------- 5962 ** 5963 ** Was Sie schon immer ueber transfermode negotiation wissen wollten ... 5964 ** 5965 ** We try to negotiate sync and wide transfer only after 5966 ** a successfull inquire command. We look at byte 7 of the 5967 ** inquire data to determine the capabilities if the target. 5968 ** 5969 ** When we try to negotiate, we append the negotiation message 5970 ** to the identify and (maybe) simple tag message. 5971 ** The host status field is set to HS_NEGOTIATE to mark this 5972 ** situation. 5973 ** 5974 ** If the target doesn't answer this message immidiately 5975 ** (as required by the standard), the SIR_NEGO_FAIL interrupt 5976 ** will be raised eventually. 5977 ** The handler removes the HS_NEGOTIATE status, and sets the 5978 ** negotiated value to the default (async / nowide). 5979 ** 5980 ** If we receive a matching answer immediately, we check it 5981 ** for validity, and set the values. 5982 ** 5983 ** If we receive a Reject message immediately, we assume the 5984 ** negotiation has failed, and fall back to standard values. 5985 ** 5986 ** If we receive a negotiation message while not in HS_NEGOTIATE 5987 ** state, it's a target initiated negotiation. We prepare a 5988 ** (hopefully) valid answer, set our parameters, and send back 5989 ** this answer to the target. 5990 ** 5991 ** If the target doesn't fetch the answer (no message out phase), 5992 ** we assume the negotiation has failed, and fall back to default 5993 ** settings. 5994 ** 5995 ** When we set the values, we adjust them in all nccbs belonging 5996 ** to this target, in the controller's register, and in the "phys" 5997 ** field of the controller's struct ncb. 5998 ** 5999 ** Possible cases: hs sir msg_in value send goto 6000 ** We try try to negotiate: 6001 ** -> target doesnt't msgin NEG FAIL noop defa. - dispatch 6002 ** -> target rejected our msg NEG FAIL reject defa. - dispatch 6003 ** -> target answered (ok) NEG SYNC sdtr set - clrack 6004 ** -> target answered (!ok) NEG SYNC sdtr defa. REJ--->msg_bad 6005 ** -> target answered (ok) NEG WIDE wdtr set - clrack 6006 ** -> target answered (!ok) NEG WIDE wdtr defa. REJ--->msg_bad 6007 ** -> any other msgin NEG FAIL noop defa. - dispatch 6008 ** 6009 ** Target tries to negotiate: 6010 ** -> incoming message --- SYNC sdtr set SDTR - 6011 ** -> incoming message --- WIDE wdtr set WDTR - 6012 ** We sent our answer: 6013 ** -> target doesn't msgout --- PROTO ? defa. - dispatch 6014 ** 6015 **----------------------------------------------------------------------------- 6016 */ 6017 6018 case SIR_NEGO_FAILED: 6019 /*------------------------------------------------------- 6020 ** 6021 ** Negotiation failed. 6022 ** Target doesn't send an answer message, 6023 ** or target rejected our message. 6024 ** 6025 ** Remove negotiation request. 6026 ** 6027 **------------------------------------------------------- 6028 */ 6029 OUTB (HS_PRT, HS_BUSY); 6030 6031 /* fall through */ 6032 6033 case SIR_NEGO_PROTO: 6034 /*------------------------------------------------------- 6035 ** 6036 ** Negotiation failed. 6037 ** Target doesn't fetch the answer message. 6038 ** 6039 **------------------------------------------------------- 6040 */ 6041 6042 if (DEBUG_FLAGS & DEBUG_NEGO) { 6043 PRINT_ADDR(cp->ccb); 6044 printf ("negotiation failed sir=%x status=%x.\n", 6045 num, cp->nego_status); 6046 }; 6047 6048 /* 6049 ** any error in negotiation: 6050 ** fall back to default mode. 6051 */ 6052 switch (cp->nego_status) { 6053 6054 case NS_SYNC: 6055 ncr_setsync (np, cp, 0, 0xe0, 0); 6056 break; 6057 6058 case NS_WIDE: 6059 ncr_setwide (np, cp, 0, 0); 6060 break; 6061 6062 }; 6063 np->msgin [0] = MSG_NOOP; 6064 np->msgout[0] = MSG_NOOP; 6065 cp->nego_status = 0; 6066 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, dispatch)); 6067 break; 6068 6069 case SIR_NEGO_SYNC: 6070 /* 6071 ** Synchronous request message received. 6072 */ 6073 6074 if (DEBUG_FLAGS & DEBUG_NEGO) { 6075 PRINT_ADDR(cp->ccb); 6076 printf ("sync msgin: "); 6077 (void) ncr_show_msg (np->msgin); 6078 printf (".\n"); 6079 }; 6080 6081 /* 6082 ** get requested values. 6083 */ 6084 6085 chg = 0; 6086 per = np->msgin[3]; 6087 ofs = np->msgin[4]; 6088 if (ofs==0) per=255; 6089 6090 /* 6091 ** check values against driver limits. 6092 */ 6093 if (per < np->minsync) 6094 {chg = 1; per = np->minsync;} 6095 if (per < tp->tinfo.user.period) 6096 {chg = 1; per = tp->tinfo.user.period;} 6097 if (ofs > tp->tinfo.user.offset) 6098 {chg = 1; ofs = tp->tinfo.user.offset;} 6099 6100 /* 6101 ** Check against controller limits. 6102 */ 6103 6104 fak = 7; 6105 scntl3 = 0; 6106 if (ofs != 0) { 6107 ncr_getsync(np, per, &fak, &scntl3); 6108 if (fak > 7) { 6109 chg = 1; 6110 ofs = 0; 6111 } 6112 } 6113 if (ofs == 0) { 6114 fak = 7; 6115 per = 0; 6116 scntl3 = 0; 6117 } 6118 6119 if (DEBUG_FLAGS & DEBUG_NEGO) { 6120 PRINT_ADDR(cp->ccb); 6121 printf ("sync: per=%d scntl3=0x%x ofs=%d fak=%d chg=%d.\n", 6122 per, scntl3, ofs, fak, chg); 6123 } 6124 6125 if (INB (HS_PRT) == HS_NEGOTIATE) { 6126 OUTB (HS_PRT, HS_BUSY); 6127 switch (cp->nego_status) { 6128 6129 case NS_SYNC: 6130 /* 6131 ** This was an answer message 6132 */ 6133 if (chg) { 6134 /* 6135 ** Answer wasn't acceptable. 6136 */ 6137 ncr_setsync (np, cp, 0, 0xe0, 0); 6138 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, msg_bad)); 6139 } else { 6140 /* 6141 ** Answer is ok. 6142 */ 6143 ncr_setsync (np,cp,scntl3,(fak<<5)|ofs, per); 6144 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, clrack)); 6145 }; 6146 return; 6147 6148 case NS_WIDE: 6149 ncr_setwide (np, cp, 0, 0); 6150 break; 6151 }; 6152 }; 6153 6154 /* 6155 ** It was a request. Set value and 6156 ** prepare an answer message 6157 */ 6158 6159 ncr_setsync (np, cp, scntl3, (fak<<5)|ofs, per); 6160 6161 np->msgout[0] = MSG_EXTENDED; 6162 np->msgout[1] = 3; 6163 np->msgout[2] = MSG_EXT_SDTR; 6164 np->msgout[3] = per; 6165 np->msgout[4] = ofs; 6166 6167 cp->nego_status = NS_SYNC; 6168 6169 if (DEBUG_FLAGS & DEBUG_NEGO) { 6170 PRINT_ADDR(cp->ccb); 6171 printf ("sync msgout: "); 6172 (void) ncr_show_msg (np->msgout); 6173 printf (".\n"); 6174 } 6175 6176 if (!ofs) { 6177 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, msg_bad)); 6178 return; 6179 } 6180 np->msgin [0] = MSG_NOOP; 6181 6182 break; 6183 6184 case SIR_NEGO_WIDE: 6185 /* 6186 ** Wide request message received. 6187 */ 6188 if (DEBUG_FLAGS & DEBUG_NEGO) { 6189 PRINT_ADDR(cp->ccb); 6190 printf ("wide msgin: "); 6191 (void) ncr_show_msg (np->msgin); 6192 printf (".\n"); 6193 }; 6194 6195 /* 6196 ** get requested values. 6197 */ 6198 6199 chg = 0; 6200 wide = np->msgin[3]; 6201 6202 /* 6203 ** check values against driver limits. 6204 */ 6205 6206 if (wide > tp->tinfo.user.width) 6207 {chg = 1; wide = tp->tinfo.user.width;} 6208 6209 if (DEBUG_FLAGS & DEBUG_NEGO) { 6210 PRINT_ADDR(cp->ccb); 6211 printf ("wide: wide=%d chg=%d.\n", wide, chg); 6212 } 6213 6214 if (INB (HS_PRT) == HS_NEGOTIATE) { 6215 OUTB (HS_PRT, HS_BUSY); 6216 switch (cp->nego_status) { 6217 6218 case NS_WIDE: 6219 /* 6220 ** This was an answer message 6221 */ 6222 if (chg) { 6223 /* 6224 ** Answer wasn't acceptable. 6225 */ 6226 ncr_setwide (np, cp, 0, 1); 6227 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, msg_bad)); 6228 } else { 6229 /* 6230 ** Answer is ok. 6231 */ 6232 ncr_setwide (np, cp, wide, 1); 6233 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, clrack)); 6234 }; 6235 return; 6236 6237 case NS_SYNC: 6238 ncr_setsync (np, cp, 0, 0xe0, 0); 6239 break; 6240 }; 6241 }; 6242 6243 /* 6244 ** It was a request, set value and 6245 ** prepare an answer message 6246 */ 6247 6248 ncr_setwide (np, cp, wide, 1); 6249 6250 np->msgout[0] = MSG_EXTENDED; 6251 np->msgout[1] = 2; 6252 np->msgout[2] = MSG_EXT_WDTR; 6253 np->msgout[3] = wide; 6254 6255 np->msgin [0] = MSG_NOOP; 6256 6257 cp->nego_status = NS_WIDE; 6258 6259 if (DEBUG_FLAGS & DEBUG_NEGO) { 6260 PRINT_ADDR(cp->ccb); 6261 printf ("wide msgout: "); 6262 (void) ncr_show_msg (np->msgout); 6263 printf (".\n"); 6264 } 6265 break; 6266 6267 /*-------------------------------------------------------------------- 6268 ** 6269 ** Processing of special messages 6270 ** 6271 **-------------------------------------------------------------------- 6272 */ 6273 6274 case SIR_REJECT_RECEIVED: 6275 /*----------------------------------------------- 6276 ** 6277 ** We received a MSG_MESSAGE_REJECT message. 6278 ** 6279 **----------------------------------------------- 6280 */ 6281 6282 PRINT_ADDR(cp->ccb); 6283 printf ("MSG_MESSAGE_REJECT received (%x:%x).\n", 6284 (unsigned)np->lastmsg, np->msgout[0]); 6285 break; 6286 6287 case SIR_REJECT_SENT: 6288 /*----------------------------------------------- 6289 ** 6290 ** We received an unknown message 6291 ** 6292 **----------------------------------------------- 6293 */ 6294 6295 PRINT_ADDR(cp->ccb); 6296 printf ("MSG_MESSAGE_REJECT sent for "); 6297 (void) ncr_show_msg (np->msgin); 6298 printf (".\n"); 6299 break; 6300 6301 /*-------------------------------------------------------------------- 6302 ** 6303 ** Processing of special messages 6304 ** 6305 **-------------------------------------------------------------------- 6306 */ 6307 6308 case SIR_IGN_RESIDUE: 6309 /*----------------------------------------------- 6310 ** 6311 ** We received an IGNORE RESIDUE message, 6312 ** which couldn't be handled by the script. 6313 ** 6314 **----------------------------------------------- 6315 */ 6316 6317 PRINT_ADDR(cp->ccb); 6318 printf ("MSG_IGN_WIDE_RESIDUE received, but not yet implemented.\n"); 6319 break; 6320 6321 case SIR_MISSING_SAVE: 6322 /*----------------------------------------------- 6323 ** 6324 ** We received an DISCONNECT message, 6325 ** but the datapointer wasn't saved before. 6326 ** 6327 **----------------------------------------------- 6328 */ 6329 6330 PRINT_ADDR(cp->ccb); 6331 printf ("MSG_DISCONNECT received, but datapointer not saved:\n" 6332 "\tdata=%x save=%x goal=%x.\n", 6333 (unsigned) INL (nc_temp), 6334 (unsigned) np->header.savep, 6335 (unsigned) np->header.goalp); 6336 break; 6337 6338 /*-------------------------------------------------------------------- 6339 ** 6340 ** Processing of a "SCSI_STATUS_QUEUE_FULL" status. 6341 ** 6342 ** XXX JGibbs - We should do the same thing for BUSY status. 6343 ** 6344 ** The current command has been rejected, 6345 ** because there are too many in the command queue. 6346 ** We have started too many commands for that target. 6347 ** 6348 **-------------------------------------------------------------------- 6349 */ 6350 case SIR_STALL_QUEUE: 6351 cp->xerr_status = XE_OK; 6352 cp->host_status = HS_COMPLETE; 6353 cp->s_status = SCSI_STATUS_QUEUE_FULL; 6354 ncr_freeze_devq(np, cp->ccb->ccb_h.path); 6355 ncr_complete(np, cp); 6356 6357 /* FALL THROUGH */ 6358 6359 case SIR_STALL_RESTART: 6360 /*----------------------------------------------- 6361 ** 6362 ** Enable selecting again, 6363 ** if NO disconnected jobs. 6364 ** 6365 **----------------------------------------------- 6366 */ 6367 /* 6368 ** Look for a disconnected job. 6369 */ 6370 cp = np->link_nccb; 6371 while (cp && cp->host_status != HS_DISCONNECT) 6372 cp = cp->link_nccb; 6373 6374 /* 6375 ** if there is one, ... 6376 */ 6377 if (cp) { 6378 /* 6379 ** wait for reselection 6380 */ 6381 OUTL (nc_dsp, NCB_SCRIPT_PHYS (np, reselect)); 6382 return; 6383 }; 6384 6385 /* 6386 ** else remove the interrupt. 6387 */ 6388 6389 printf ("%s: queue empty.\n", ncr_name (np)); 6390 WRITESCRIPT(start1[0], SCR_INT ^ IFFALSE (0)); 6391 break; 6392 }; 6393 6394 out: 6395 OUTB (nc_dcntl, np->rv_dcntl | STD); 6396 } 6397 6398 /*========================================================== 6399 ** 6400 ** 6401 ** Aquire a control block 6402 ** 6403 ** 6404 **========================================================== 6405 */ 6406 6407 static nccb_p ncr_get_nccb 6408 (ncb_p np, u_long target, u_long lun) 6409 { 6410 lcb_p lp; 6411 int s; 6412 nccb_p cp = NULL; 6413 6414 /* Keep our timeout handler out */ 6415 s = splsoftclock(); 6416 6417 /* 6418 ** Lun structure available ? 6419 */ 6420 6421 lp = np->target[target].lp[lun]; 6422 if (lp) { 6423 cp = lp->next_nccb; 6424 6425 /* 6426 ** Look for free CCB 6427 */ 6428 6429 while (cp && cp->magic) { 6430 cp = cp->next_nccb; 6431 } 6432 } 6433 6434 /* 6435 ** if nothing available, create one. 6436 */ 6437 6438 if (cp == NULL) 6439 cp = ncr_alloc_nccb(np, target, lun); 6440 6441 if (cp != NULL) { 6442 if (cp->magic) { 6443 printf("%s: Bogus free cp found\n", ncr_name(np)); 6444 splx(s); 6445 return (NULL); 6446 } 6447 cp->magic = 1; 6448 } 6449 splx(s); 6450 return (cp); 6451 } 6452 6453 /*========================================================== 6454 ** 6455 ** 6456 ** Release one control block 6457 ** 6458 ** 6459 **========================================================== 6460 */ 6461 6462 void ncr_free_nccb (ncb_p np, nccb_p cp) 6463 { 6464 /* 6465 ** sanity 6466 */ 6467 6468 assert (cp != NULL); 6469 6470 cp -> host_status = HS_IDLE; 6471 cp -> magic = 0; 6472 } 6473 6474 /*========================================================== 6475 ** 6476 ** 6477 ** Allocation of resources for Targets/Luns/Tags. 6478 ** 6479 ** 6480 **========================================================== 6481 */ 6482 6483 static nccb_p 6484 ncr_alloc_nccb (ncb_p np, u_long target, u_long lun) 6485 { 6486 tcb_p tp; 6487 lcb_p lp; 6488 nccb_p cp; 6489 6490 assert (np != NULL); 6491 6492 if (target>=MAX_TARGET) return(NULL); 6493 if (lun >=MAX_LUN ) return(NULL); 6494 6495 tp=&np->target[target]; 6496 6497 if (!tp->jump_tcb.l_cmd) { 6498 6499 /* 6500 ** initialize it. 6501 */ 6502 tp->jump_tcb.l_cmd = (SCR_JUMP^IFFALSE (DATA (0x80 + target))); 6503 tp->jump_tcb.l_paddr = np->jump_tcb.l_paddr; 6504 6505 tp->getscr[0] = 6506 (np->features & FE_PFEN)? SCR_COPY(1) : SCR_COPY_F(1); 6507 tp->getscr[1] = vtophys (&tp->tinfo.sval); 6508 tp->getscr[2] = rman_get_start(np->reg_res) + offsetof (struct ncr_reg, nc_sxfer); 6509 tp->getscr[3] = 6510 (np->features & FE_PFEN)? SCR_COPY(1) : SCR_COPY_F(1); 6511 tp->getscr[4] = vtophys (&tp->tinfo.wval); 6512 tp->getscr[5] = rman_get_start(np->reg_res) + offsetof (struct ncr_reg, nc_scntl3); 6513 6514 assert (((offsetof(struct ncr_reg, nc_sxfer) ^ 6515 (offsetof(struct tcb ,tinfo) 6516 + offsetof(struct ncr_target_tinfo, sval))) & 3) == 0); 6517 assert (((offsetof(struct ncr_reg, nc_scntl3) ^ 6518 (offsetof(struct tcb, tinfo) 6519 + offsetof(struct ncr_target_tinfo, wval))) &3) == 0); 6520 6521 tp->call_lun.l_cmd = (SCR_CALL); 6522 tp->call_lun.l_paddr = NCB_SCRIPT_PHYS (np, resel_lun); 6523 6524 tp->jump_lcb.l_cmd = (SCR_JUMP); 6525 tp->jump_lcb.l_paddr = NCB_SCRIPTH_PHYS (np, abort); 6526 np->jump_tcb.l_paddr = vtophys (&tp->jump_tcb); 6527 } 6528 6529 /* 6530 ** Logic unit control block 6531 */ 6532 lp = tp->lp[lun]; 6533 if (!lp) { 6534 /* 6535 ** Allocate a lcb 6536 */ 6537 lp = (lcb_p) malloc (sizeof (struct lcb), M_DEVBUF, M_NOWAIT); 6538 if (!lp) return(NULL); 6539 6540 /* 6541 ** Initialize it 6542 */ 6543 bzero (lp, sizeof (*lp)); 6544 lp->jump_lcb.l_cmd = (SCR_JUMP ^ IFFALSE (DATA (lun))); 6545 lp->jump_lcb.l_paddr = tp->jump_lcb.l_paddr; 6546 6547 lp->call_tag.l_cmd = (SCR_CALL); 6548 lp->call_tag.l_paddr = NCB_SCRIPT_PHYS (np, resel_tag); 6549 6550 lp->jump_nccb.l_cmd = (SCR_JUMP); 6551 lp->jump_nccb.l_paddr = NCB_SCRIPTH_PHYS (np, aborttag); 6552 6553 lp->actlink = 1; 6554 6555 /* 6556 ** Chain into LUN list 6557 */ 6558 tp->jump_lcb.l_paddr = vtophys (&lp->jump_lcb); 6559 tp->lp[lun] = lp; 6560 6561 } 6562 6563 /* 6564 ** Allocate a nccb 6565 */ 6566 cp = (nccb_p) malloc (sizeof (struct nccb), M_DEVBUF, M_NOWAIT); 6567 6568 if (!cp) 6569 return (NULL); 6570 6571 if (DEBUG_FLAGS & DEBUG_ALLOC) { 6572 printf ("new nccb @%p.\n", cp); 6573 } 6574 6575 /* 6576 ** Initialize it 6577 */ 6578 bzero (cp, sizeof (*cp)); 6579 6580 /* 6581 ** Fill in physical addresses 6582 */ 6583 6584 cp->p_nccb = vtophys (cp); 6585 6586 /* 6587 ** Chain into reselect list 6588 */ 6589 cp->jump_nccb.l_cmd = SCR_JUMP; 6590 cp->jump_nccb.l_paddr = lp->jump_nccb.l_paddr; 6591 lp->jump_nccb.l_paddr = CCB_PHYS (cp, jump_nccb); 6592 cp->call_tmp.l_cmd = SCR_CALL; 6593 cp->call_tmp.l_paddr = NCB_SCRIPT_PHYS (np, resel_tmp); 6594 6595 /* 6596 ** Chain into wakeup list 6597 */ 6598 cp->link_nccb = np->link_nccb; 6599 np->link_nccb = cp; 6600 6601 /* 6602 ** Chain into CCB list 6603 */ 6604 cp->next_nccb = lp->next_nccb; 6605 lp->next_nccb = cp; 6606 6607 return (cp); 6608 } 6609 6610 /*========================================================== 6611 ** 6612 ** 6613 ** Build Scatter Gather Block 6614 ** 6615 ** 6616 **========================================================== 6617 ** 6618 ** The transfer area may be scattered among 6619 ** several non adjacent physical pages. 6620 ** 6621 ** We may use MAX_SCATTER blocks. 6622 ** 6623 **---------------------------------------------------------- 6624 */ 6625 6626 static int ncr_scatter 6627 (struct dsb* phys, vm_offset_t vaddr, vm_size_t datalen) 6628 { 6629 u_long paddr, pnext; 6630 6631 u_short segment = 0; 6632 u_long segsize, segaddr; 6633 u_long size, csize = 0; 6634 u_long chunk = MAX_SIZE; 6635 int free; 6636 6637 bzero (&phys->data, sizeof (phys->data)); 6638 if (!datalen) return (0); 6639 6640 paddr = vtophys (vaddr); 6641 6642 /* 6643 ** insert extra break points at a distance of chunk. 6644 ** We try to reduce the number of interrupts caused 6645 ** by unexpected phase changes due to disconnects. 6646 ** A typical harddisk may disconnect before ANY block. 6647 ** If we wanted to avoid unexpected phase changes at all 6648 ** we had to use a break point every 512 bytes. 6649 ** Of course the number of scatter/gather blocks is 6650 ** limited. 6651 */ 6652 6653 free = MAX_SCATTER - 1; 6654 6655 if (vaddr & PAGE_MASK) free -= datalen / PAGE_SIZE; 6656 6657 if (free>1) 6658 while ((chunk * free >= 2 * datalen) && (chunk>=1024)) 6659 chunk /= 2; 6660 6661 if(DEBUG_FLAGS & DEBUG_SCATTER) 6662 printf("ncr?:\tscattering virtual=%p size=%d chunk=%d.\n", 6663 (void *) vaddr, (unsigned) datalen, (unsigned) chunk); 6664 6665 /* 6666 ** Build data descriptors. 6667 */ 6668 while (datalen && (segment < MAX_SCATTER)) { 6669 6670 /* 6671 ** this segment is empty 6672 */ 6673 segsize = 0; 6674 segaddr = paddr; 6675 pnext = paddr; 6676 6677 if (!csize) csize = chunk; 6678 6679 while ((datalen) && (paddr == pnext) && (csize)) { 6680 6681 /* 6682 ** continue this segment 6683 */ 6684 pnext = (paddr & (~PAGE_MASK)) + PAGE_SIZE; 6685 6686 /* 6687 ** Compute max size 6688 */ 6689 6690 size = pnext - paddr; /* page size */ 6691 if (size > datalen) size = datalen; /* data size */ 6692 if (size > csize ) size = csize ; /* chunksize */ 6693 6694 segsize += size; 6695 vaddr += size; 6696 csize -= size; 6697 datalen -= size; 6698 paddr = vtophys (vaddr); 6699 }; 6700 6701 if(DEBUG_FLAGS & DEBUG_SCATTER) 6702 printf ("\tseg #%d addr=%x size=%d (rest=%d).\n", 6703 segment, 6704 (unsigned) segaddr, 6705 (unsigned) segsize, 6706 (unsigned) datalen); 6707 6708 phys->data[segment].addr = segaddr; 6709 phys->data[segment].size = segsize; 6710 segment++; 6711 } 6712 6713 if (datalen) { 6714 printf("ncr?: scatter/gather failed (residue=%d).\n", 6715 (unsigned) datalen); 6716 return (-1); 6717 }; 6718 6719 return (segment); 6720 } 6721 6722 /*========================================================== 6723 ** 6724 ** 6725 ** Test the pci bus snoop logic :-( 6726 ** 6727 ** Has to be called with interrupts disabled. 6728 ** 6729 ** 6730 **========================================================== 6731 */ 6732 6733 #ifndef NCR_IOMAPPED 6734 static int ncr_regtest (struct ncb* np) 6735 { 6736 volatile u_int32_t data; 6737 /* 6738 ** ncr registers may NOT be cached. 6739 ** write 0xffffffff to a read only register area, 6740 ** and try to read it back. 6741 */ 6742 data = 0xffffffff; 6743 OUTL_OFF(offsetof(struct ncr_reg, nc_dstat), data); 6744 data = INL_OFF(offsetof(struct ncr_reg, nc_dstat)); 6745 #if 1 6746 if (data == 0xffffffff) { 6747 #else 6748 if ((data & 0xe2f0fffd) != 0x02000080) { 6749 #endif 6750 printf ("CACHE TEST FAILED: reg dstat-sstat2 readback %x.\n", 6751 (unsigned) data); 6752 return (0x10); 6753 }; 6754 return (0); 6755 } 6756 #endif 6757 6758 static int ncr_snooptest (struct ncb* np) 6759 { 6760 u_int32_t ncr_rd, ncr_wr, ncr_bk, host_rd, host_wr, pc; 6761 int i, err=0; 6762 #ifndef NCR_IOMAPPED 6763 err |= ncr_regtest (np); 6764 if (err) return (err); 6765 #endif 6766 /* 6767 ** init 6768 */ 6769 pc = NCB_SCRIPTH_PHYS (np, snooptest); 6770 host_wr = 1; 6771 ncr_wr = 2; 6772 /* 6773 ** Set memory and register. 6774 */ 6775 ncr_cache = host_wr; 6776 OUTL (nc_temp, ncr_wr); 6777 /* 6778 ** Start script (exchange values) 6779 */ 6780 OUTL (nc_dsp, pc); 6781 /* 6782 ** Wait 'til done (with timeout) 6783 */ 6784 for (i=0; i<NCR_SNOOP_TIMEOUT; i++) 6785 if (INB(nc_istat) & (INTF|SIP|DIP)) 6786 break; 6787 /* 6788 ** Save termination position. 6789 */ 6790 pc = INL (nc_dsp); 6791 /* 6792 ** Read memory and register. 6793 */ 6794 host_rd = ncr_cache; 6795 ncr_rd = INL (nc_scratcha); 6796 ncr_bk = INL (nc_temp); 6797 /* 6798 ** Reset ncr chip 6799 */ 6800 OUTB (nc_istat, SRST); 6801 DELAY (1000); 6802 OUTB (nc_istat, 0 ); 6803 /* 6804 ** check for timeout 6805 */ 6806 if (i>=NCR_SNOOP_TIMEOUT) { 6807 printf ("CACHE TEST FAILED: timeout.\n"); 6808 return (0x20); 6809 }; 6810 /* 6811 ** Check termination position. 6812 */ 6813 if (pc != NCB_SCRIPTH_PHYS (np, snoopend)+8) { 6814 printf ("CACHE TEST FAILED: script execution failed.\n"); 6815 printf ("start=%08lx, pc=%08lx, end=%08lx\n", 6816 (u_long) NCB_SCRIPTH_PHYS (np, snooptest), (u_long) pc, 6817 (u_long) NCB_SCRIPTH_PHYS (np, snoopend) +8); 6818 return (0x40); 6819 }; 6820 /* 6821 ** Show results. 6822 */ 6823 if (host_wr != ncr_rd) { 6824 printf ("CACHE TEST FAILED: host wrote %d, ncr read %d.\n", 6825 (int) host_wr, (int) ncr_rd); 6826 err |= 1; 6827 }; 6828 if (host_rd != ncr_wr) { 6829 printf ("CACHE TEST FAILED: ncr wrote %d, host read %d.\n", 6830 (int) ncr_wr, (int) host_rd); 6831 err |= 2; 6832 }; 6833 if (ncr_bk != ncr_wr) { 6834 printf ("CACHE TEST FAILED: ncr wrote %d, read back %d.\n", 6835 (int) ncr_wr, (int) ncr_bk); 6836 err |= 4; 6837 }; 6838 return (err); 6839 } 6840 6841 /*========================================================== 6842 ** 6843 ** 6844 ** Profiling the drivers and targets performance. 6845 ** 6846 ** 6847 **========================================================== 6848 */ 6849 6850 /* 6851 ** Compute the difference in milliseconds. 6852 **/ 6853 6854 static int ncr_delta (int *from, int *to) 6855 { 6856 if (!from) return (-1); 6857 if (!to) return (-2); 6858 return ((to - from) * 1000 / hz); 6859 } 6860 6861 #define PROFILE cp->phys.header.stamp 6862 static void ncb_profile (ncb_p np, nccb_p cp) 6863 { 6864 int co, da, st, en, di, se, post,work,disc; 6865 u_long diff; 6866 6867 PROFILE.end = ticks; 6868 6869 st = ncr_delta (&PROFILE.start,&PROFILE.status); 6870 if (st<0) return; /* status not reached */ 6871 6872 da = ncr_delta (&PROFILE.start,&PROFILE.data); 6873 if (da<0) return; /* No data transfer phase */ 6874 6875 co = ncr_delta (&PROFILE.start,&PROFILE.command); 6876 if (co<0) return; /* command not executed */ 6877 6878 en = ncr_delta (&PROFILE.start,&PROFILE.end), 6879 di = ncr_delta (&PROFILE.start,&PROFILE.disconnect), 6880 se = ncr_delta (&PROFILE.start,&PROFILE.select); 6881 post = en - st; 6882 6883 /* 6884 ** @PROFILE@ Disconnect time invalid if multiple disconnects 6885 */ 6886 6887 if (di>=0) disc = se-di; else disc = 0; 6888 6889 work = (st - co) - disc; 6890 6891 diff = (np->disc_phys - np->disc_ref) & 0xff; 6892 np->disc_ref += diff; 6893 6894 np->profile.num_trans += 1; 6895 if (cp->ccb) 6896 np->profile.num_bytes += cp->ccb->csio.dxfer_len; 6897 np->profile.num_disc += diff; 6898 np->profile.ms_setup += co; 6899 np->profile.ms_data += work; 6900 np->profile.ms_disc += disc; 6901 np->profile.ms_post += post; 6902 } 6903 #undef PROFILE 6904 6905 /*========================================================== 6906 ** 6907 ** Determine the ncr's clock frequency. 6908 ** This is essential for the negotiation 6909 ** of the synchronous transfer rate. 6910 ** 6911 **========================================================== 6912 ** 6913 ** Note: we have to return the correct value. 6914 ** THERE IS NO SAVE DEFAULT VALUE. 6915 ** 6916 ** Most NCR/SYMBIOS boards are delivered with a 40 Mhz clock. 6917 ** 53C860 and 53C875 rev. 1 support fast20 transfers but 6918 ** do not have a clock doubler and so are provided with a 6919 ** 80 MHz clock. All other fast20 boards incorporate a doubler 6920 ** and so should be delivered with a 40 MHz clock. 6921 ** The future fast40 chips (895/895) use a 40 Mhz base clock 6922 ** and provide a clock quadrupler (160 Mhz). The code below 6923 ** tries to deal as cleverly as possible with all this stuff. 6924 ** 6925 **---------------------------------------------------------- 6926 */ 6927 6928 /* 6929 * Select NCR SCSI clock frequency 6930 */ 6931 static void ncr_selectclock(ncb_p np, u_char scntl3) 6932 { 6933 if (np->multiplier < 2) { 6934 OUTB(nc_scntl3, scntl3); 6935 return; 6936 } 6937 6938 if (bootverbose >= 2) 6939 printf ("%s: enabling clock multiplier\n", ncr_name(np)); 6940 6941 OUTB(nc_stest1, DBLEN); /* Enable clock multiplier */ 6942 if (np->multiplier > 2) { /* Poll bit 5 of stest4 for quadrupler */ 6943 int i = 20; 6944 while (!(INB(nc_stest4) & LCKFRQ) && --i > 0) 6945 DELAY(20); 6946 if (!i) 6947 printf("%s: the chip cannot lock the frequency\n", ncr_name(np)); 6948 } else /* Wait 20 micro-seconds for doubler */ 6949 DELAY(20); 6950 OUTB(nc_stest3, HSC); /* Halt the scsi clock */ 6951 OUTB(nc_scntl3, scntl3); 6952 OUTB(nc_stest1, (DBLEN|DBLSEL));/* Select clock multiplier */ 6953 OUTB(nc_stest3, 0x00); /* Restart scsi clock */ 6954 } 6955 6956 /* 6957 * calculate NCR SCSI clock frequency (in KHz) 6958 */ 6959 static unsigned 6960 ncrgetfreq (ncb_p np, int gen) 6961 { 6962 int ms = 0; 6963 /* 6964 * Measure GEN timer delay in order 6965 * to calculate SCSI clock frequency 6966 * 6967 * This code will never execute too 6968 * many loop iterations (if DELAY is 6969 * reasonably correct). It could get 6970 * too low a delay (too high a freq.) 6971 * if the CPU is slow executing the 6972 * loop for some reason (an NMI, for 6973 * example). For this reason we will 6974 * if multiple measurements are to be 6975 * performed trust the higher delay 6976 * (lower frequency returned). 6977 */ 6978 OUTB (nc_stest1, 0); /* make sure clock doubler is OFF */ 6979 OUTW (nc_sien , 0); /* mask all scsi interrupts */ 6980 (void) INW (nc_sist); /* clear pending scsi interrupt */ 6981 OUTB (nc_dien , 0); /* mask all dma interrupts */ 6982 (void) INW (nc_sist); /* another one, just to be sure :) */ 6983 OUTB (nc_scntl3, 4); /* set pre-scaler to divide by 3 */ 6984 OUTB (nc_stime1, 0); /* disable general purpose timer */ 6985 OUTB (nc_stime1, gen); /* set to nominal delay of (1<<gen) * 125us */ 6986 while (!(INW(nc_sist) & GEN) && ms++ < 1000) 6987 DELAY(1000); /* count ms */ 6988 OUTB (nc_stime1, 0); /* disable general purpose timer */ 6989 OUTB (nc_scntl3, 0); 6990 /* 6991 * Set prescaler to divide by whatever "0" means. 6992 * "0" ought to choose divide by 2, but appears 6993 * to set divide by 3.5 mode in my 53c810 ... 6994 */ 6995 OUTB (nc_scntl3, 0); 6996 6997 if (bootverbose >= 2) 6998 printf ("\tDelay (GEN=%d): %u msec\n", gen, ms); 6999 /* 7000 * adjust for prescaler, and convert into KHz 7001 */ 7002 return ms ? ((1 << gen) * 4440) / ms : 0; 7003 } 7004 7005 static void ncr_getclock (ncb_p np, u_char multiplier) 7006 { 7007 unsigned char scntl3; 7008 unsigned char stest1; 7009 scntl3 = INB(nc_scntl3); 7010 stest1 = INB(nc_stest1); 7011 7012 np->multiplier = 1; 7013 7014 if (multiplier > 1) { 7015 np->multiplier = multiplier; 7016 np->clock_khz = 40000 * multiplier; 7017 } else { 7018 if ((scntl3 & 7) == 0) { 7019 unsigned f1, f2; 7020 /* throw away first result */ 7021 (void) ncrgetfreq (np, 11); 7022 f1 = ncrgetfreq (np, 11); 7023 f2 = ncrgetfreq (np, 11); 7024 7025 if (bootverbose >= 2) 7026 printf ("\tNCR clock is %uKHz, %uKHz\n", f1, f2); 7027 if (f1 > f2) f1 = f2; /* trust lower result */ 7028 if (f1 > 45000) { 7029 scntl3 = 5; /* >45Mhz: assume 80MHz */ 7030 } else { 7031 scntl3 = 3; /* <45Mhz: assume 40MHz */ 7032 } 7033 } 7034 else if ((scntl3 & 7) == 5) 7035 np->clock_khz = 80000; /* Probably a 875 rev. 1 ? */ 7036 } 7037 } 7038 7039 /*=========================================================================*/ 7040 7041 #ifdef NCR_TEKRAM_EEPROM 7042 7043 struct tekram_eeprom_dev { 7044 u_char devmode; 7045 #define TKR_PARCHK 0x01 7046 #define TKR_TRYSYNC 0x02 7047 #define TKR_ENDISC 0x04 7048 #define TKR_STARTUNIT 0x08 7049 #define TKR_USETAGS 0x10 7050 #define TKR_TRYWIDE 0x20 7051 u_char syncparam; /* max. sync transfer rate (table ?) */ 7052 u_char filler1; 7053 u_char filler2; 7054 }; 7055 7056 7057 struct tekram_eeprom { 7058 struct tekram_eeprom_dev 7059 dev[16]; 7060 u_char adaptid; 7061 u_char adaptmode; 7062 #define TKR_ADPT_GT2DRV 0x01 7063 #define TKR_ADPT_GT1GB 0x02 7064 #define TKR_ADPT_RSTBUS 0x04 7065 #define TKR_ADPT_ACTNEG 0x08 7066 #define TKR_ADPT_NOSEEK 0x10 7067 #define TKR_ADPT_MORLUN 0x20 7068 u_char delay; /* unit ? ( table ??? ) */ 7069 u_char tags; /* use 4 times as many ... */ 7070 u_char filler[60]; 7071 }; 7072 7073 static void 7074 tekram_write_bit (ncb_p np, int bit) 7075 { 7076 u_char val = 0x10 + ((bit & 1) << 1); 7077 7078 DELAY(10); 7079 OUTB (nc_gpreg, val); 7080 DELAY(10); 7081 OUTB (nc_gpreg, val | 0x04); 7082 DELAY(10); 7083 OUTB (nc_gpreg, val); 7084 DELAY(10); 7085 } 7086 7087 static int 7088 tekram_read_bit (ncb_p np) 7089 { 7090 OUTB (nc_gpreg, 0x10); 7091 DELAY(10); 7092 OUTB (nc_gpreg, 0x14); 7093 DELAY(10); 7094 return INB (nc_gpreg) & 1; 7095 } 7096 7097 static u_short 7098 read_tekram_eeprom_reg (ncb_p np, int reg) 7099 { 7100 int bit; 7101 u_short result = 0; 7102 int cmd = 0x80 | reg; 7103 7104 OUTB (nc_gpreg, 0x10); 7105 7106 tekram_write_bit (np, 1); 7107 for (bit = 7; bit >= 0; bit--) 7108 { 7109 tekram_write_bit (np, cmd >> bit); 7110 } 7111 7112 for (bit = 0; bit < 16; bit++) 7113 { 7114 result <<= 1; 7115 result |= tekram_read_bit (np); 7116 } 7117 7118 OUTB (nc_gpreg, 0x00); 7119 return result; 7120 } 7121 7122 static int 7123 read_tekram_eeprom(ncb_p np, struct tekram_eeprom *buffer) 7124 { 7125 u_short *p = (u_short *) buffer; 7126 u_short sum = 0; 7127 int i; 7128 7129 if (INB (nc_gpcntl) != 0x09) 7130 { 7131 return 0; 7132 } 7133 for (i = 0; i < 64; i++) 7134 { 7135 u_short val; 7136 if((i&0x0f) == 0) printf ("%02x:", i*2); 7137 val = read_tekram_eeprom_reg (np, i); 7138 if (p) 7139 *p++ = val; 7140 sum += val; 7141 if((i&0x01) == 0x00) printf (" "); 7142 printf ("%02x%02x", val & 0xff, (val >> 8) & 0xff); 7143 if((i&0x0f) == 0x0f) printf ("\n"); 7144 } 7145 printf ("Sum = %04x\n", sum); 7146 return sum == 0x1234; 7147 } 7148 #endif /* NCR_TEKRAM_EEPROM */ 7149 7150 static device_method_t ncr_methods[] = { 7151 /* Device interface */ 7152 DEVMETHOD(device_probe, ncr_probe), 7153 DEVMETHOD(device_attach, ncr_attach), 7154 7155 { 0, 0 } 7156 }; 7157 7158 static driver_t ncr_driver = { 7159 "ncr", 7160 ncr_methods, 7161 sizeof(struct ncb), 7162 }; 7163 7164 static devclass_t ncr_devclass; 7165 7166 DRIVER_MODULE(if_ncr, pci, ncr_driver, ncr_devclass, 0, 0); 7167 7168 /*=========================================================================*/ 7169 #endif /* _KERNEL */ 7170