1 /* aha152x.c -- Adaptec AHA-152x driver 2 * Author: J�rgen E. Fischer, fischer@norbit.de 3 * Copyright 1993-2004 J�rgen E. Fischer 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License as published by the 7 * Free Software Foundation; either version 2, or (at your option) any 8 * later version. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * 16 * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $ 17 * 18 * $Log: aha152x.c,v $ 19 * Revision 2.7 2004/01/24 11:42:59 fischer 20 * - gather code that is not used by PCMCIA at the end 21 * - move request_region for !PCMCIA case to detection 22 * - migration to new scsi host api (remove legacy code) 23 * - free host scribble before scsi_done 24 * - fix error handling 25 * - one isapnp device added to id_table 26 * 27 * Revision 2.6 2003/10/30 20:52:47 fischer 28 * - interfaces changes for kernel 2.6 29 * - aha152x_probe_one introduced for pcmcia stub 30 * - fixed pnpdev handling 31 * - instead of allocation a new one, reuse command for request sense after check condition and reset 32 * - fixes race in is_complete 33 * 34 * Revision 2.5 2002/04/14 11:24:53 fischer 35 * - isapnp support 36 * - abort fixed 37 * - 2.5 support 38 * 39 * Revision 2.4 2000/12/16 12:53:56 fischer 40 * - allow REQUEST SENSE to be queued 41 * - handle shared PCI interrupts 42 * 43 * Revision 2.3 2000/11/04 16:40:26 fischer 44 * - handle data overruns 45 * - extend timeout for data phases 46 * 47 * Revision 2.2 2000/08/08 19:54:53 fischer 48 * - minor changes 49 * 50 * Revision 2.1 2000/05/17 16:23:17 fischer 51 * - signature update 52 * - fix for data out w/o scatter gather 53 * 54 * Revision 2.0 1999/12/25 15:07:32 fischer 55 * - interrupt routine completly reworked 56 * - basic support for new eh code 57 * 58 * Revision 1.21 1999/11/10 23:46:36 fischer 59 * - default to synchronous operation 60 * - synchronous negotiation fixed 61 * - added timeout to loops 62 * - debugging output can be controlled through procfs 63 * 64 * Revision 1.20 1999/11/07 18:37:31 fischer 65 * - synchronous operation works 66 * - resid support for sg driver 67 * 68 * Revision 1.19 1999/11/02 22:39:59 fischer 69 * - moved leading comments to README.aha152x 70 * - new additional module parameters 71 * - updates for 2.3 72 * - support for the Tripace TC1550 controller 73 * - interrupt handling changed 74 * 75 * Revision 1.18 1996/09/07 20:10:40 fischer 76 * - fixed can_queue handling (multiple outstanding commands working again) 77 * 78 * Revision 1.17 1996/08/17 16:05:14 fischer 79 * - biosparam improved 80 * - interrupt verification 81 * - updated documentation 82 * - cleanups 83 * 84 * Revision 1.16 1996/06/09 00:04:56 root 85 * - added configuration symbols for insmod (aha152x/aha152x1) 86 * 87 * Revision 1.15 1996/04/30 14:52:06 fischer 88 * - proc info fixed 89 * - support for extended translation for >1GB disks 90 * 91 * Revision 1.14 1996/01/17 15:11:20 fischer 92 * - fixed lockup in MESSAGE IN phase after reconnection 93 * 94 * Revision 1.13 1996/01/09 02:15:53 fischer 95 * - some cleanups 96 * - moved request_irq behind controller initialization 97 * (to avoid spurious interrupts) 98 * 99 * Revision 1.12 1995/12/16 12:26:07 fischer 100 * - barrier()s added 101 * - configurable RESET delay added 102 * 103 * Revision 1.11 1995/12/06 21:18:35 fischer 104 * - some minor updates 105 * 106 * Revision 1.10 1995/07/22 19:18:45 fischer 107 * - support for 2 controllers 108 * - started synchronous data transfers (not working yet) 109 * 110 * Revision 1.9 1995/03/18 09:20:24 root 111 * - patches for PCMCIA and modules 112 * 113 * Revision 1.8 1995/01/21 22:07:19 root 114 * - snarf_region => request_region 115 * - aha152x_intr interface change 116 * 117 * Revision 1.7 1995/01/02 23:19:36 root 118 * - updated COMMAND_SIZE to cmd_len 119 * - changed sti() to restore_flags() 120 * - fixed some #ifdef which generated warnings 121 * 122 * Revision 1.6 1994/11/24 20:35:27 root 123 * - problem with odd number of bytes in fifo fixed 124 * 125 * Revision 1.5 1994/10/30 14:39:56 root 126 * - abort code fixed 127 * - debugging improved 128 * 129 * Revision 1.4 1994/09/12 11:33:01 root 130 * - irqaction to request_irq 131 * - abortion updated 132 * 133 * Revision 1.3 1994/08/04 13:53:05 root 134 * - updates for mid-level-driver changes 135 * - accept unexpected BUSFREE phase as error condition 136 * - parity check now configurable 137 * 138 * Revision 1.2 1994/07/03 12:56:36 root 139 * - cleaned up debugging code 140 * - more tweaking on reset delays 141 * - updated abort/reset code (pretty untested...) 142 * 143 * Revision 1.1 1994/05/28 21:18:49 root 144 * - update for mid-level interface change (abort-reset) 145 * - delays after resets adjusted for some slow devices 146 * 147 * Revision 1.0 1994/03/25 12:52:00 root 148 * - Fixed "more data than expected" problem 149 * - added new BIOS signatures 150 * 151 * Revision 0.102 1994/01/31 20:44:12 root 152 * - minor changes in insw/outsw handling 153 * 154 * Revision 0.101 1993/12/13 01:16:27 root 155 * - fixed STATUS phase (non-GOOD stati were dropped sometimes; 156 * fixes problems with CD-ROM sector size detection & media change) 157 * 158 * Revision 0.100 1993/12/10 16:58:47 root 159 * - fix for unsuccessful selections in case of non-continuous id assignments 160 * on the scsi bus. 161 * 162 * Revision 0.99 1993/10/24 16:19:59 root 163 * - fixed DATA IN (rare read errors gone) 164 * 165 * Revision 0.98 1993/10/17 12:54:44 root 166 * - fixed some recent fixes (shame on me) 167 * - moved initialization of scratch area to aha152x_queue 168 * 169 * Revision 0.97 1993/10/09 18:53:53 root 170 * - DATA IN fixed. Rarely left data in the fifo. 171 * 172 * Revision 0.96 1993/10/03 00:53:59 root 173 * - minor changes on DATA IN 174 * 175 * Revision 0.95 1993/09/24 10:36:01 root 176 * - change handling of MSGI after reselection 177 * - fixed sti/cli 178 * - minor changes 179 * 180 * Revision 0.94 1993/09/18 14:08:22 root 181 * - fixed bug in multiple outstanding command code 182 * - changed detection 183 * - support for kernel command line configuration 184 * - reset corrected 185 * - changed message handling 186 * 187 * Revision 0.93 1993/09/15 20:41:19 root 188 * - fixed bugs with multiple outstanding commands 189 * 190 * Revision 0.92 1993/09/13 02:46:33 root 191 * - multiple outstanding commands work (no problems with IBM drive) 192 * 193 * Revision 0.91 1993/09/12 20:51:46 root 194 * added multiple outstanding commands 195 * (some problem with this $%&? IBM device remain) 196 * 197 * Revision 0.9 1993/09/12 11:11:22 root 198 * - corrected auto-configuration 199 * - changed the auto-configuration (added some '#define's) 200 * - added support for dis-/reconnection 201 * 202 * Revision 0.8 1993/09/06 23:09:39 root 203 * - added support for the drive activity light 204 * - minor changes 205 * 206 * Revision 0.7 1993/09/05 14:30:15 root 207 * - improved phase detection 208 * - now using the new snarf_region code of 0.99pl13 209 * 210 * Revision 0.6 1993/09/02 11:01:38 root 211 * first public release; added some signatures and biosparam() 212 * 213 * Revision 0.5 1993/08/30 10:23:30 root 214 * fixed timing problems with my IBM drive 215 * 216 * Revision 0.4 1993/08/29 14:06:52 root 217 * fixed some problems with timeouts due incomplete commands 218 * 219 * Revision 0.3 1993/08/28 15:55:03 root 220 * writing data works too. mounted and worked on a dos partition 221 * 222 * Revision 0.2 1993/08/27 22:42:07 root 223 * reading data works. Mounted a msdos partition. 224 * 225 * Revision 0.1 1993/08/25 13:38:30 root 226 * first "damn thing doesn't work" version 227 * 228 * Revision 0.0 1993/08/14 19:54:25 root 229 * empty function bodies; detect() works. 230 * 231 * 232 ************************************************************************** 233 234 see Documentation/scsi/aha152x.txt for configuration details 235 236 **************************************************************************/ 237 238 #include <linux/module.h> 239 #include <linux/sched.h> 240 #include <asm/irq.h> 241 #include <asm/io.h> 242 #include <linux/blkdev.h> 243 #include <asm/system.h> 244 #include <linux/errno.h> 245 #include <linux/string.h> 246 #include <linux/wait.h> 247 #include <linux/ioport.h> 248 #include <linux/delay.h> 249 #include <linux/proc_fs.h> 250 #include <linux/interrupt.h> 251 #include <linux/init.h> 252 #include <linux/kernel.h> 253 #include <linux/isapnp.h> 254 #include <linux/spinlock.h> 255 #include <linux/workqueue.h> 256 #include <asm/semaphore.h> 257 #include <scsi/scsicam.h> 258 259 #include "scsi.h" 260 #include <scsi/scsi_dbg.h> 261 #include <scsi/scsi_host.h> 262 #include "aha152x.h" 263 264 265 /* DEFINES */ 266 267 /* For PCMCIA cards, always use AUTOCONF */ 268 #if defined(PCMCIA) || defined(MODULE) 269 #if !defined(AUTOCONF) 270 #define AUTOCONF 271 #endif 272 #endif 273 274 #if !defined(AUTOCONF) && !defined(SETUP0) 275 #error define AUTOCONF or SETUP0 276 #endif 277 278 #if defined(AHA152X_DEBUG) 279 #define DEBUG_DEFAULT debug_eh 280 281 #define DPRINTK(when,msgs...) \ 282 do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0) 283 284 #define DO_LOCK(flags) \ 285 do { \ 286 if(spin_is_locked(&QLOCK)) { \ 287 DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \ 288 } \ 289 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \ 290 spin_lock_irqsave(&QLOCK,flags); \ 291 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \ 292 QLOCKER=__FUNCTION__; \ 293 QLOCKERL=__LINE__; \ 294 } while(0) 295 296 #define DO_UNLOCK(flags) \ 297 do { \ 298 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \ 299 spin_unlock_irqrestore(&QLOCK,flags); \ 300 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \ 301 QLOCKER="(not locked)"; \ 302 QLOCKERL=0; \ 303 } while(0) 304 305 #else 306 #define DPRINTK(when,msgs...) 307 #define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags) 308 #define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags) 309 #endif 310 311 #define LEAD "(scsi%d:%d:%d) " 312 #define WARN_LEAD KERN_WARNING LEAD 313 #define INFO_LEAD KERN_INFO LEAD 314 #define NOTE_LEAD KERN_NOTICE LEAD 315 #define ERR_LEAD KERN_ERR LEAD 316 #define DEBUG_LEAD KERN_DEBUG LEAD 317 #define CMDINFO(cmd) \ 318 (cmd) ? ((cmd)->device->host->host_no) : -1, \ 319 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \ 320 (cmd) ? ((cmd)->device->lun & 0x07) : -1 321 322 #define DELAY_DEFAULT 1000 323 324 #if defined(PCMCIA) 325 #define IRQ_MIN 0 326 #define IRQ_MAX 16 327 #else 328 #define IRQ_MIN 9 329 #if defined(__PPC) 330 #define IRQ_MAX (NR_IRQS-1) 331 #else 332 #define IRQ_MAX 12 333 #endif 334 #endif 335 336 enum { 337 not_issued = 0x0001, /* command not yet issued */ 338 selecting = 0x0002, /* target is beeing selected */ 339 identified = 0x0004, /* IDENTIFY was sent */ 340 disconnected = 0x0008, /* target disconnected */ 341 completed = 0x0010, /* target sent COMMAND COMPLETE */ 342 aborted = 0x0020, /* ABORT was sent */ 343 resetted = 0x0040, /* BUS DEVICE RESET was sent */ 344 spiordy = 0x0080, /* waiting for SPIORDY to raise */ 345 syncneg = 0x0100, /* synchronous negotiation in progress */ 346 aborting = 0x0200, /* ABORT is pending */ 347 resetting = 0x0400, /* BUS DEVICE RESET is pending */ 348 check_condition = 0x0800, /* requesting sense after CHECK CONDITION */ 349 }; 350 351 MODULE_AUTHOR("J�rgen Fischer"); 352 MODULE_DESCRIPTION(AHA152X_REVID); 353 MODULE_LICENSE("GPL"); 354 355 #if !defined(PCMCIA) 356 #if defined(MODULE) 357 static int io[] = {0, 0}; 358 module_param_array(io, int, NULL, 0); 359 MODULE_PARM_DESC(io,"base io address of controller"); 360 361 static int irq[] = {0, 0}; 362 module_param_array(irq, int, NULL, 0); 363 MODULE_PARM_DESC(irq,"interrupt for controller"); 364 365 static int scsiid[] = {7, 7}; 366 module_param_array(scsiid, int, NULL, 0); 367 MODULE_PARM_DESC(scsiid,"scsi id of controller"); 368 369 static int reconnect[] = {1, 1}; 370 module_param_array(reconnect, int, NULL, 0); 371 MODULE_PARM_DESC(reconnect,"allow targets to disconnect"); 372 373 static int parity[] = {1, 1}; 374 module_param_array(parity, int, NULL, 0); 375 MODULE_PARM_DESC(parity,"use scsi parity"); 376 377 static int sync[] = {1, 1}; 378 module_param_array(sync, int, NULL, 0); 379 MODULE_PARM_DESC(sync,"use synchronous transfers"); 380 381 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT}; 382 module_param_array(delay, int, NULL, 0); 383 MODULE_PARM_DESC(delay,"scsi reset delay"); 384 385 static int exttrans[] = {0, 0}; 386 module_param_array(exttrans, int, NULL, 0); 387 MODULE_PARM_DESC(exttrans,"use extended translation"); 388 389 #if !defined(AHA152X_DEBUG) 390 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0}; 391 module_param_array(aha152x, int, NULL, 0); 392 MODULE_PARM_DESC(aha152x, "parameters for first controller"); 393 394 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0}; 395 module_param_array(aha152x1, int, NULL, 0); 396 MODULE_PARM_DESC(aha152x1, "parameters for second controller"); 397 #else 398 static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT}; 399 module_param_array(debug, int, NULL, 0); 400 MODULE_PARM_DESC(debug, "flags for driver debugging"); 401 402 static int aha152x[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT}; 403 module_param_array(aha152x, int, NULL, 0); 404 MODULE_PARM_DESC(aha152x, "parameters for first controller"); 405 406 static int aha152x1[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT}; 407 module_param_array(aha152x1, int, NULL, 0); 408 MODULE_PARM_DESC(aha152x1, "parameters for second controller"); 409 #endif /* !defined(AHA152X_DEBUG) */ 410 #endif /* MODULE */ 411 412 #ifdef __ISAPNP__ 413 static struct isapnp_device_id id_table[] __devinitdata = { 414 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, 415 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1505), 0 }, 416 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, 417 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1530), 0 }, 418 { ISAPNP_DEVICE_SINGLE_END, } 419 }; 420 MODULE_DEVICE_TABLE(isapnp, id_table); 421 #endif /* ISAPNP */ 422 423 #endif /* !PCMCIA */ 424 425 static int registered_count=0; 426 static struct Scsi_Host *aha152x_host[2]; 427 static Scsi_Host_Template aha152x_driver_template; 428 429 /* 430 * internal states of the host 431 * 432 */ 433 enum aha152x_state { 434 idle=0, 435 unknown, 436 seldo, 437 seldi, 438 selto, 439 busfree, 440 msgo, 441 cmd, 442 msgi, 443 status, 444 datai, 445 datao, 446 parerr, 447 rsti, 448 maxstate 449 }; 450 451 /* 452 * current state information of the host 453 * 454 */ 455 struct aha152x_hostdata { 456 Scsi_Cmnd *issue_SC; 457 /* pending commands to issue */ 458 459 Scsi_Cmnd *current_SC; 460 /* current command on the bus */ 461 462 Scsi_Cmnd *disconnected_SC; 463 /* commands that disconnected */ 464 465 Scsi_Cmnd *done_SC; 466 /* command that was completed */ 467 468 spinlock_t lock; 469 /* host lock */ 470 471 #if defined(AHA152X_DEBUG) 472 const char *locker; 473 /* which function has the lock */ 474 int lockerl; /* where did it get it */ 475 476 int debug; /* current debugging setting */ 477 #endif 478 479 #if defined(AHA152X_STAT) 480 int total_commands; 481 int disconnections; 482 int busfree_without_any_action; 483 int busfree_without_old_command; 484 int busfree_without_new_command; 485 int busfree_without_done_command; 486 int busfree_with_check_condition; 487 int count[maxstate]; 488 int count_trans[maxstate]; 489 unsigned long time[maxstate]; 490 #endif 491 492 int commands; /* current number of commands */ 493 494 int reconnect; /* disconnection allowed */ 495 int parity; /* parity checking enabled */ 496 int synchronous; /* synchronous transferes enabled */ 497 int delay; /* reset out delay */ 498 int ext_trans; /* extended translation enabled */ 499 500 int swint; /* software-interrupt was fired during detect() */ 501 int service; /* bh needs to be run */ 502 int in_intr; /* bh is running */ 503 504 /* current state, 505 previous state, 506 last state different from current state */ 507 enum aha152x_state state, prevstate, laststate; 508 509 int target; 510 /* reconnecting target */ 511 512 unsigned char syncrate[8]; 513 /* current synchronous transfer agreements */ 514 515 unsigned char syncneg[8]; 516 /* 0: no negotiation; 517 * 1: negotiation in progress; 518 * 2: negotiation completed 519 */ 520 521 int cmd_i; 522 /* number of sent bytes of current command */ 523 524 int msgi_len; 525 /* number of received message bytes */ 526 unsigned char msgi[256]; 527 /* received message bytes */ 528 529 int msgo_i, msgo_len; 530 /* number of sent bytes and length of current messages */ 531 unsigned char msgo[256]; 532 /* pending messages */ 533 534 int data_len; 535 /* number of sent/received bytes in dataphase */ 536 537 unsigned long io_port0; 538 unsigned long io_port1; 539 540 #ifdef __ISAPNP__ 541 struct pnp_dev *pnpdev; 542 #endif 543 }; 544 545 546 /* 547 * host specific command extension 548 * 549 */ 550 struct aha152x_scdata { 551 Scsi_Cmnd *next; /* next sc in queue */ 552 struct semaphore *sem; /* semaphore to block on */ 553 }; 554 555 556 /* access macros for hostdata */ 557 558 #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata) 559 560 #define HOSTNO ((shpnt)->host_no) 561 562 #define CURRENT_SC (HOSTDATA(shpnt)->current_SC) 563 #define DONE_SC (HOSTDATA(shpnt)->done_SC) 564 #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC) 565 #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC) 566 #define QLOCK (HOSTDATA(shpnt)->lock) 567 #define QLOCKER (HOSTDATA(shpnt)->locker) 568 #define QLOCKERL (HOSTDATA(shpnt)->lockerl) 569 570 #define STATE (HOSTDATA(shpnt)->state) 571 #define PREVSTATE (HOSTDATA(shpnt)->prevstate) 572 #define LASTSTATE (HOSTDATA(shpnt)->laststate) 573 574 #define RECONN_TARGET (HOSTDATA(shpnt)->target) 575 576 #define CMD_I (HOSTDATA(shpnt)->cmd_i) 577 578 #define MSGO(i) (HOSTDATA(shpnt)->msgo[i]) 579 #define MSGO_I (HOSTDATA(shpnt)->msgo_i) 580 #define MSGOLEN (HOSTDATA(shpnt)->msgo_len) 581 #define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow")) 582 583 #define MSGI(i) (HOSTDATA(shpnt)->msgi[i]) 584 #define MSGILEN (HOSTDATA(shpnt)->msgi_len) 585 #define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow")) 586 587 #define DATA_LEN (HOSTDATA(shpnt)->data_len) 588 589 #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id]) 590 #define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id]) 591 592 #define DELAY (HOSTDATA(shpnt)->delay) 593 #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans) 594 #define TC1550 (HOSTDATA(shpnt)->tc1550) 595 #define RECONNECT (HOSTDATA(shpnt)->reconnect) 596 #define PARITY (HOSTDATA(shpnt)->parity) 597 #define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous) 598 599 #define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0) 600 #define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1) 601 602 #define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble) 603 #define SCNEXT(SCpnt) SCDATA(SCpnt)->next 604 #define SCSEM(SCpnt) SCDATA(SCpnt)->sem 605 606 #define SG_ADDRESS(buffer) ((char *) (page_address((buffer)->page)+(buffer)->offset)) 607 608 /* state handling */ 609 static void seldi_run(struct Scsi_Host *shpnt); 610 static void seldo_run(struct Scsi_Host *shpnt); 611 static void selto_run(struct Scsi_Host *shpnt); 612 static void busfree_run(struct Scsi_Host *shpnt); 613 614 static void msgo_init(struct Scsi_Host *shpnt); 615 static void msgo_run(struct Scsi_Host *shpnt); 616 static void msgo_end(struct Scsi_Host *shpnt); 617 618 static void cmd_init(struct Scsi_Host *shpnt); 619 static void cmd_run(struct Scsi_Host *shpnt); 620 static void cmd_end(struct Scsi_Host *shpnt); 621 622 static void datai_init(struct Scsi_Host *shpnt); 623 static void datai_run(struct Scsi_Host *shpnt); 624 static void datai_end(struct Scsi_Host *shpnt); 625 626 static void datao_init(struct Scsi_Host *shpnt); 627 static void datao_run(struct Scsi_Host *shpnt); 628 static void datao_end(struct Scsi_Host *shpnt); 629 630 static void status_run(struct Scsi_Host *shpnt); 631 632 static void msgi_run(struct Scsi_Host *shpnt); 633 static void msgi_end(struct Scsi_Host *shpnt); 634 635 static void parerr_run(struct Scsi_Host *shpnt); 636 static void rsti_run(struct Scsi_Host *shpnt); 637 638 static void is_complete(struct Scsi_Host *shpnt); 639 640 /* 641 * driver states 642 * 643 */ 644 static struct { 645 char *name; 646 void (*init)(struct Scsi_Host *); 647 void (*run)(struct Scsi_Host *); 648 void (*end)(struct Scsi_Host *); 649 int spio; 650 } states[] = { 651 { "idle", NULL, NULL, NULL, 0}, 652 { "unknown", NULL, NULL, NULL, 0}, 653 { "seldo", NULL, seldo_run, NULL, 0}, 654 { "seldi", NULL, seldi_run, NULL, 0}, 655 { "selto", NULL, selto_run, NULL, 0}, 656 { "busfree", NULL, busfree_run, NULL, 0}, 657 { "msgo", msgo_init, msgo_run, msgo_end, 1}, 658 { "cmd", cmd_init, cmd_run, cmd_end, 1}, 659 { "msgi", NULL, msgi_run, msgi_end, 1}, 660 { "status", NULL, status_run, NULL, 1}, 661 { "datai", datai_init, datai_run, datai_end, 0}, 662 { "datao", datao_init, datao_run, datao_end, 0}, 663 { "parerr", NULL, parerr_run, NULL, 0}, 664 { "rsti", NULL, rsti_run, NULL, 0}, 665 }; 666 667 /* setup & interrupt */ 668 static irqreturn_t intr(int irq, void *dev_id, struct pt_regs *); 669 static void reset_ports(struct Scsi_Host *shpnt); 670 static void aha152x_error(struct Scsi_Host *shpnt, char *msg); 671 static void done(struct Scsi_Host *shpnt, int error); 672 673 /* diagnostics */ 674 static void disp_ports(struct Scsi_Host *shpnt); 675 static void show_command(Scsi_Cmnd * ptr); 676 static void show_queues(struct Scsi_Host *shpnt); 677 static void disp_enintr(struct Scsi_Host *shpnt); 678 679 680 /* 681 * queue services: 682 * 683 */ 684 static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC) 685 { 686 Scsi_Cmnd *end; 687 688 SCNEXT(new_SC) = NULL; 689 if (!*SC) 690 *SC = new_SC; 691 else { 692 for (end = *SC; SCNEXT(end); end = SCNEXT(end)) 693 ; 694 SCNEXT(end) = new_SC; 695 } 696 } 697 698 static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC) 699 { 700 Scsi_Cmnd *ptr; 701 702 ptr = *SC; 703 if (ptr) { 704 *SC = SCNEXT(*SC); 705 SCNEXT(ptr)=NULL; 706 } 707 return ptr; 708 } 709 710 static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun) 711 { 712 Scsi_Cmnd *ptr, *prev; 713 714 for (ptr = *SC, prev = NULL; 715 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun)); 716 prev = ptr, ptr = SCNEXT(ptr)) 717 ; 718 719 if (ptr) { 720 if (prev) 721 SCNEXT(prev) = SCNEXT(ptr); 722 else 723 *SC = SCNEXT(ptr); 724 725 SCNEXT(ptr)=NULL; 726 } 727 728 return ptr; 729 } 730 731 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp) 732 { 733 Scsi_Cmnd *ptr, *prev; 734 735 for (ptr = *SC, prev = NULL; 736 ptr && SCp!=ptr; 737 prev = ptr, ptr = SCNEXT(ptr)) 738 ; 739 740 if (ptr) { 741 if (prev) 742 SCNEXT(prev) = SCNEXT(ptr); 743 else 744 *SC = SCNEXT(ptr); 745 746 SCNEXT(ptr)=NULL; 747 } 748 749 return ptr; 750 } 751 752 static inline struct Scsi_Host *lookup_irq(int irqno) 753 { 754 int i; 755 756 for(i=0; i<ARRAY_SIZE(aha152x_host); i++) 757 if(aha152x_host[i] && aha152x_host[i]->irq==irqno) 758 return aha152x_host[i]; 759 760 return NULL; 761 } 762 763 static irqreturn_t swintr(int irqno, void *dev_id, struct pt_regs *regs) 764 { 765 struct Scsi_Host *shpnt = lookup_irq(irqno); 766 767 if (!shpnt) { 768 printk(KERN_ERR "aha152x: catched software interrupt %d for unknown controller.\n", irqno); 769 return IRQ_NONE; 770 } 771 772 HOSTDATA(shpnt)->swint++; 773 774 SETPORT(DMACNTRL0, INTEN); 775 return IRQ_HANDLED; 776 } 777 778 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup) 779 { 780 struct Scsi_Host *shpnt; 781 782 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata)); 783 if (!shpnt) { 784 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n"); 785 return NULL; 786 } 787 788 /* need to have host registered before triggering any interrupt */ 789 aha152x_host[registered_count] = shpnt; 790 791 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt)); 792 793 shpnt->io_port = setup->io_port; 794 shpnt->n_io_port = IO_RANGE; 795 shpnt->irq = setup->irq; 796 797 if (!setup->tc1550) { 798 HOSTIOPORT0 = setup->io_port; 799 HOSTIOPORT1 = setup->io_port; 800 } else { 801 HOSTIOPORT0 = setup->io_port+0x10; 802 HOSTIOPORT1 = setup->io_port-0x10; 803 } 804 805 spin_lock_init(&QLOCK); 806 RECONNECT = setup->reconnect; 807 SYNCHRONOUS = setup->synchronous; 808 PARITY = setup->parity; 809 DELAY = setup->delay; 810 EXT_TRANS = setup->ext_trans; 811 812 #if defined(AHA152X_DEBUG) 813 HOSTDATA(shpnt)->debug = setup->debug; 814 #endif 815 816 SETPORT(SCSIID, setup->scsiid << 4); 817 shpnt->this_id = setup->scsiid; 818 819 if (setup->reconnect) 820 shpnt->can_queue = AHA152X_MAXQUEUE; 821 822 /* RESET OUT */ 823 printk("aha152x: resetting bus...\n"); 824 SETPORT(SCSISEQ, SCSIRSTO); 825 mdelay(256); 826 SETPORT(SCSISEQ, 0); 827 mdelay(DELAY); 828 829 reset_ports(shpnt); 830 831 printk(KERN_INFO 832 "aha152x%d%s: " 833 "vital data: rev=%x, " 834 "io=0x%03lx (0x%03lx/0x%03lx), " 835 "irq=%d, " 836 "scsiid=%d, " 837 "reconnect=%s, " 838 "parity=%s, " 839 "synchronous=%s, " 840 "delay=%d, " 841 "extended translation=%s\n", 842 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "", 843 GETPORT(REV) & 0x7, 844 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1, 845 shpnt->irq, 846 shpnt->this_id, 847 RECONNECT ? "enabled" : "disabled", 848 PARITY ? "enabled" : "disabled", 849 SYNCHRONOUS ? "enabled" : "disabled", 850 DELAY, 851 EXT_TRANS ? "enabled" : "disabled"); 852 853 /* not expecting any interrupts */ 854 SETPORT(SIMODE0, 0); 855 SETPORT(SIMODE1, 0); 856 857 if( request_irq(shpnt->irq, swintr, SA_INTERRUPT|SA_SHIRQ, "aha152x", shpnt) ) { 858 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq); 859 goto out_host_put; 860 } 861 862 HOSTDATA(shpnt)->swint = 0; 863 864 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no); 865 866 mb(); 867 SETPORT(DMACNTRL0, SWINT|INTEN); 868 mdelay(1000); 869 free_irq(shpnt->irq, shpnt); 870 871 if (!HOSTDATA(shpnt)->swint) { 872 if (TESTHI(DMASTAT, INTSTAT)) { 873 printk("lost.\n"); 874 } else { 875 printk("failed.\n"); 876 } 877 878 SETPORT(DMACNTRL0, INTEN); 879 880 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. " 881 "Please verify.\n", shpnt->host_no, shpnt->irq); 882 goto out_host_put; 883 } 884 printk("ok.\n"); 885 886 887 /* clear interrupts */ 888 SETPORT(SSTAT0, 0x7f); 889 SETPORT(SSTAT1, 0xef); 890 891 if ( request_irq(shpnt->irq, intr, SA_INTERRUPT|SA_SHIRQ, "aha152x", shpnt) ) { 892 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq); 893 goto out_host_put; 894 } 895 896 if( scsi_add_host(shpnt, NULL) ) { 897 free_irq(shpnt->irq, shpnt); 898 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no); 899 goto out_host_put; 900 } 901 902 scsi_scan_host(shpnt); 903 904 registered_count++; 905 906 return shpnt; 907 908 out_host_put: 909 aha152x_host[registered_count]=NULL; 910 scsi_host_put(shpnt); 911 912 return NULL; 913 } 914 915 void aha152x_release(struct Scsi_Host *shpnt) 916 { 917 if(!shpnt) 918 return; 919 920 if (shpnt->irq) 921 free_irq(shpnt->irq, shpnt); 922 923 #if !defined(PCMCIA) 924 if (shpnt->io_port) 925 release_region(shpnt->io_port, IO_RANGE); 926 #endif 927 928 #ifdef __ISAPNP__ 929 if (HOSTDATA(shpnt)->pnpdev) 930 pnp_device_detach(HOSTDATA(shpnt)->pnpdev); 931 #endif 932 933 scsi_remove_host(shpnt); 934 scsi_host_put(shpnt); 935 } 936 937 938 /* 939 * setup controller to generate interrupts depending 940 * on current state (lock has to be acquired) 941 * 942 */ 943 static int setup_expected_interrupts(struct Scsi_Host *shpnt) 944 { 945 if(CURRENT_SC) { 946 CURRENT_SC->SCp.phase |= 1 << 16; 947 948 if(CURRENT_SC->SCp.phase & selecting) { 949 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC)); 950 SETPORT(SSTAT1, SELTO); 951 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0)); 952 SETPORT(SIMODE1, ENSELTIMO); 953 } else { 954 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : ""); 955 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0); 956 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 957 } 958 } else if(STATE==seldi) { 959 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC)); 960 SETPORT(SIMODE0, 0); 961 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 962 } else { 963 DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n", 964 CMDINFO(CURRENT_SC), 965 DISCONNECTED_SC ? "(reselection)" : "", 966 ISSUE_SC ? "(busfree)" : ""); 967 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0); 968 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0)); 969 } 970 971 if(!HOSTDATA(shpnt)->in_intr) 972 SETBITS(DMACNTRL0, INTEN); 973 974 return TESTHI(DMASTAT, INTSTAT); 975 } 976 977 978 /* 979 * Queue a command and setup interrupts for a free bus. 980 */ 981 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct semaphore *sem, int phase, void (*done)(Scsi_Cmnd *)) 982 { 983 struct Scsi_Host *shpnt = SCpnt->device->host; 984 unsigned long flags; 985 986 #if defined(AHA152X_DEBUG) 987 if (HOSTDATA(shpnt)->debug & debug_queue) { 988 printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=", 989 CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len, SCpnt->use_sg, SCpnt->request_bufflen); 990 __scsi_print_command(SCpnt->cmnd); 991 } 992 #endif 993 994 SCpnt->scsi_done = done; 995 SCpnt->resid = SCpnt->request_bufflen; 996 SCpnt->SCp.phase = not_issued | phase; 997 SCpnt->SCp.Status = CHECK_CONDITION; 998 SCpnt->SCp.Message = 0; 999 SCpnt->SCp.have_data_in = 0; 1000 SCpnt->SCp.sent_command = 0; 1001 1002 if(SCpnt->SCp.phase & (resetting|check_condition)) { 1003 if(SCpnt->host_scribble==0 || SCSEM(SCpnt) || SCNEXT(SCpnt)) { 1004 printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt)); 1005 return FAILED; 1006 } 1007 } else { 1008 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC); 1009 if(SCpnt->host_scribble==0) { 1010 printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt)); 1011 return FAILED; 1012 } 1013 } 1014 1015 SCNEXT(SCpnt) = NULL; 1016 SCSEM(SCpnt) = sem; 1017 1018 /* setup scratch area 1019 SCp.ptr : buffer pointer 1020 SCp.this_residual : buffer length 1021 SCp.buffer : next buffer 1022 SCp.buffers_residual : left buffers in list 1023 SCp.phase : current state of the command */ 1024 if (SCpnt->use_sg) { 1025 SCpnt->SCp.buffer = (struct scatterlist *) SCpnt->request_buffer; 1026 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer); 1027 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; 1028 SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1; 1029 } else { 1030 SCpnt->SCp.ptr = (char *) SCpnt->request_buffer; 1031 SCpnt->SCp.this_residual = SCpnt->request_bufflen; 1032 SCpnt->SCp.buffer = NULL; 1033 SCpnt->SCp.buffers_residual = 0; 1034 } 1035 1036 DO_LOCK(flags); 1037 1038 #if defined(AHA152X_STAT) 1039 HOSTDATA(shpnt)->total_commands++; 1040 #endif 1041 1042 /* Turn led on, when this is the first command. */ 1043 HOSTDATA(shpnt)->commands++; 1044 if (HOSTDATA(shpnt)->commands==1) 1045 SETPORT(PORTA, 1); 1046 1047 append_SC(&ISSUE_SC, SCpnt); 1048 1049 if(!HOSTDATA(shpnt)->in_intr) 1050 setup_expected_interrupts(shpnt); 1051 1052 DO_UNLOCK(flags); 1053 1054 return 0; 1055 } 1056 1057 /* 1058 * queue a command 1059 * 1060 */ 1061 static int aha152x_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) 1062 { 1063 #if 0 1064 if(*SCpnt->cmnd == REQUEST_SENSE) { 1065 SCpnt->result = 0; 1066 done(SCpnt); 1067 1068 return 0; 1069 } 1070 #endif 1071 1072 return aha152x_internal_queue(SCpnt, NULL, 0, done); 1073 } 1074 1075 1076 /* 1077 * 1078 * 1079 */ 1080 static void reset_done(Scsi_Cmnd *SCpnt) 1081 { 1082 #if 0 1083 struct Scsi_Host *shpnt = SCpnt->host; 1084 DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt)); 1085 #endif 1086 if(SCSEM(SCpnt)) { 1087 up(SCSEM(SCpnt)); 1088 } else { 1089 printk(KERN_ERR "aha152x: reset_done w/o semaphore\n"); 1090 } 1091 } 1092 1093 /* 1094 * Abort a command 1095 * 1096 */ 1097 static int aha152x_abort(Scsi_Cmnd *SCpnt) 1098 { 1099 struct Scsi_Host *shpnt = SCpnt->device->host; 1100 Scsi_Cmnd *ptr; 1101 unsigned long flags; 1102 1103 #if defined(AHA152X_DEBUG) 1104 if(HOSTDATA(shpnt)->debug & debug_eh) { 1105 printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt); 1106 show_queues(shpnt); 1107 } 1108 #endif 1109 1110 DO_LOCK(flags); 1111 1112 ptr=remove_SC(&ISSUE_SC, SCpnt); 1113 1114 if(ptr) { 1115 DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt)); 1116 1117 HOSTDATA(shpnt)->commands--; 1118 if (!HOSTDATA(shpnt)->commands) 1119 SETPORT(PORTA, 0); 1120 DO_UNLOCK(flags); 1121 1122 kfree(SCpnt->host_scribble); 1123 SCpnt->host_scribble=NULL; 1124 1125 return SUCCESS; 1126 } 1127 1128 DO_UNLOCK(flags); 1129 1130 /* 1131 * FIXME: 1132 * for current command: queue ABORT for message out and raise ATN 1133 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection? 1134 * 1135 */ 1136 1137 printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt)); 1138 1139 return FAILED; 1140 } 1141 1142 static void timer_expired(unsigned long p) 1143 { 1144 Scsi_Cmnd *SCp = (Scsi_Cmnd *)p; 1145 struct semaphore *sem = SCSEM(SCp); 1146 struct Scsi_Host *shpnt = SCp->device->host; 1147 unsigned long flags; 1148 1149 /* remove command from issue queue */ 1150 DO_LOCK(flags); 1151 remove_SC(&ISSUE_SC, SCp); 1152 DO_UNLOCK(flags); 1153 1154 up(sem); 1155 } 1156 1157 /* 1158 * Reset a device 1159 * 1160 */ 1161 static int aha152x_device_reset(Scsi_Cmnd * SCpnt) 1162 { 1163 struct Scsi_Host *shpnt = SCpnt->device->host; 1164 DECLARE_MUTEX_LOCKED(sem); 1165 struct timer_list timer; 1166 int ret, issued, disconnected; 1167 unsigned long flags; 1168 1169 #if defined(AHA152X_DEBUG) 1170 if(HOSTDATA(shpnt)->debug & debug_eh) { 1171 printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt); 1172 show_queues(shpnt); 1173 } 1174 #endif 1175 1176 if(CURRENT_SC==SCpnt) { 1177 printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt)); 1178 return FAILED; 1179 } 1180 1181 DO_LOCK(flags); 1182 issued = remove_SC(&ISSUE_SC, SCpnt)==0; 1183 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt); 1184 DO_UNLOCK(flags); 1185 1186 SCpnt->cmd_len = 0; 1187 SCpnt->use_sg = 0; 1188 SCpnt->request_buffer = NULL; 1189 SCpnt->request_bufflen = 0; 1190 1191 init_timer(&timer); 1192 timer.data = (unsigned long) SCpnt; 1193 timer.expires = jiffies + 100*HZ; /* 10s */ 1194 timer.function = (void (*)(unsigned long)) timer_expired; 1195 1196 aha152x_internal_queue(SCpnt, &sem, resetting, reset_done); 1197 add_timer(&timer); 1198 down(&sem); 1199 del_timer(&timer); 1200 1201 SCpnt->cmd_len = SCpnt->old_cmd_len; 1202 SCpnt->use_sg = SCpnt->old_use_sg; 1203 SCpnt->request_buffer = SCpnt->buffer; 1204 SCpnt->request_bufflen = SCpnt->bufflen; 1205 1206 DO_LOCK(flags); 1207 1208 if(SCpnt->SCp.phase & resetted) { 1209 HOSTDATA(shpnt)->commands--; 1210 if (!HOSTDATA(shpnt)->commands) 1211 SETPORT(PORTA, 0); 1212 kfree(SCpnt->host_scribble); 1213 SCpnt->host_scribble=NULL; 1214 1215 ret = SUCCESS; 1216 } else { 1217 /* requeue */ 1218 if(!issued) { 1219 append_SC(&ISSUE_SC, SCpnt); 1220 } else if(disconnected) { 1221 append_SC(&DISCONNECTED_SC, SCpnt); 1222 } 1223 1224 ret = FAILED; 1225 } 1226 1227 DO_UNLOCK(flags); 1228 1229 spin_lock_irq(shpnt->host_lock); 1230 return ret; 1231 } 1232 1233 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs) 1234 { 1235 Scsi_Cmnd *ptr; 1236 1237 ptr=*SCs; 1238 while(ptr) { 1239 Scsi_Cmnd *next; 1240 1241 if(SCDATA(ptr)) { 1242 next = SCNEXT(ptr); 1243 } else { 1244 printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr); 1245 next = NULL; 1246 } 1247 1248 if (!ptr->device->soft_reset) { 1249 DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr); 1250 remove_SC(SCs, ptr); 1251 HOSTDATA(shpnt)->commands--; 1252 kfree(ptr->host_scribble); 1253 ptr->host_scribble=NULL; 1254 } 1255 1256 ptr = next; 1257 } 1258 } 1259 1260 /* 1261 * Reset the bus 1262 * 1263 */ 1264 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt) 1265 { 1266 struct Scsi_Host *shpnt = SCpnt->device->host; 1267 unsigned long flags; 1268 1269 DO_LOCK(flags); 1270 1271 #if defined(AHA152X_DEBUG) 1272 if(HOSTDATA(shpnt)->debug & debug_eh) { 1273 printk(DEBUG_LEAD "aha152x_bus_reset(%p)", CMDINFO(SCpnt), SCpnt); 1274 show_queues(shpnt); 1275 } 1276 #endif 1277 1278 free_hard_reset_SCs(shpnt, &ISSUE_SC); 1279 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC); 1280 1281 DPRINTK(debug_eh, DEBUG_LEAD "resetting bus\n", CMDINFO(SCpnt)); 1282 1283 SETPORT(SCSISEQ, SCSIRSTO); 1284 mdelay(256); 1285 SETPORT(SCSISEQ, 0); 1286 mdelay(DELAY); 1287 1288 DPRINTK(debug_eh, DEBUG_LEAD "bus resetted\n", CMDINFO(SCpnt)); 1289 1290 setup_expected_interrupts(shpnt); 1291 if(HOSTDATA(shpnt)->commands==0) 1292 SETPORT(PORTA, 0); 1293 1294 DO_UNLOCK(flags); 1295 1296 return SUCCESS; 1297 } 1298 1299 1300 /* 1301 * Restore default values to the AIC-6260 registers and reset the fifos 1302 * 1303 */ 1304 static void reset_ports(struct Scsi_Host *shpnt) 1305 { 1306 unsigned long flags; 1307 1308 /* disable interrupts */ 1309 SETPORT(DMACNTRL0, RSTFIFO); 1310 1311 SETPORT(SCSISEQ, 0); 1312 1313 SETPORT(SXFRCTL1, 0); 1314 SETPORT(SCSISIG, 0); 1315 SETRATE(0); 1316 1317 /* clear all interrupt conditions */ 1318 SETPORT(SSTAT0, 0x7f); 1319 SETPORT(SSTAT1, 0xef); 1320 1321 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR); 1322 1323 SETPORT(DMACNTRL0, 0); 1324 SETPORT(DMACNTRL1, 0); 1325 1326 SETPORT(BRSTCNTRL, 0xf1); 1327 1328 /* clear SCSI fifos and transfer count */ 1329 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 1330 SETPORT(SXFRCTL0, CH1); 1331 1332 DO_LOCK(flags); 1333 setup_expected_interrupts(shpnt); 1334 DO_UNLOCK(flags); 1335 } 1336 1337 /* 1338 * Reset the host (bus and controller) 1339 * 1340 */ 1341 int aha152x_host_reset(Scsi_Cmnd * SCpnt) 1342 { 1343 #if defined(AHA152X_DEBUG) 1344 struct Scsi_Host *shpnt = SCpnt->device->host; 1345 #endif 1346 1347 DPRINTK(debug_eh, DEBUG_LEAD "aha152x_host_reset(%p)\n", CMDINFO(SCpnt), SCpnt); 1348 1349 aha152x_bus_reset(SCpnt); 1350 1351 DPRINTK(debug_eh, DEBUG_LEAD "resetting ports\n", CMDINFO(SCpnt)); 1352 reset_ports(SCpnt->device->host); 1353 1354 return SUCCESS; 1355 } 1356 1357 /* 1358 * Return the "logical geometry" 1359 * 1360 */ 1361 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev, 1362 sector_t capacity, int *info_array) 1363 { 1364 struct Scsi_Host *shpnt = sdev->host; 1365 1366 /* try default translation */ 1367 info_array[0] = 64; 1368 info_array[1] = 32; 1369 info_array[2] = (unsigned long)capacity / (64 * 32); 1370 1371 /* for disks >1GB do some guessing */ 1372 if (info_array[2] >= 1024) { 1373 int info[3]; 1374 1375 /* try to figure out the geometry from the partition table */ 1376 if (scsicam_bios_param(bdev, capacity, info) < 0 || 1377 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) { 1378 if (EXT_TRANS) { 1379 printk(KERN_NOTICE 1380 "aha152x: unable to verify geometry for disk with >1GB.\n" 1381 " using extended translation.\n"); 1382 info_array[0] = 255; 1383 info_array[1] = 63; 1384 info_array[2] = (unsigned long)capacity / (255 * 63); 1385 } else { 1386 printk(KERN_NOTICE 1387 "aha152x: unable to verify geometry for disk with >1GB.\n" 1388 " Using default translation. Please verify yourself.\n" 1389 " Perhaps you need to enable extended translation in the driver.\n" 1390 " See Documentation/scsi/aha152x.txt for details.\n"); 1391 } 1392 } else { 1393 info_array[0] = info[0]; 1394 info_array[1] = info[1]; 1395 info_array[2] = info[2]; 1396 1397 if (info[0] == 255 && !EXT_TRANS) { 1398 printk(KERN_NOTICE 1399 "aha152x: current partition table is using extended translation.\n" 1400 " using it also, although it's not explicitly enabled.\n"); 1401 } 1402 } 1403 } 1404 1405 return 0; 1406 } 1407 1408 /* 1409 * Internal done function 1410 * 1411 */ 1412 static void done(struct Scsi_Host *shpnt, int error) 1413 { 1414 if (CURRENT_SC) { 1415 if(DONE_SC) 1416 printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC); 1417 1418 DONE_SC = CURRENT_SC; 1419 CURRENT_SC = NULL; 1420 DONE_SC->result = error; 1421 } else 1422 printk(KERN_ERR "aha152x: done() called outside of command\n"); 1423 } 1424 1425 static struct work_struct aha152x_tq; 1426 1427 /* 1428 * Run service completions on the card with interrupts enabled. 1429 * 1430 */ 1431 static void run(void) 1432 { 1433 int i; 1434 for (i = 0; i<ARRAY_SIZE(aha152x_host); i++) { 1435 struct Scsi_Host *shpnt = aha152x_host[i]; 1436 if (shpnt && HOSTDATA(shpnt)->service) { 1437 HOSTDATA(shpnt)->service=0; 1438 is_complete(shpnt); 1439 } 1440 } 1441 } 1442 1443 /* 1444 * Interrupts handler 1445 * 1446 */ 1447 1448 static irqreturn_t intr(int irqno, void *dev_id, struct pt_regs *regs) 1449 { 1450 struct Scsi_Host *shpnt = lookup_irq(irqno); 1451 unsigned char rev, dmacntrl0; 1452 1453 if (!shpnt) { 1454 printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno); 1455 return IRQ_NONE; 1456 } 1457 1458 /* 1459 * Read a couple of registers that are known to not be all 1's. If 1460 * we read all 1's (-1), that means that either: 1461 * 1462 * a. The host adapter chip has gone bad, and we cannot control it, 1463 * OR 1464 * b. The host adapter is a PCMCIA card that has been ejected 1465 * 1466 * In either case, we cannot do anything with the host adapter at 1467 * this point in time. So just ignore the interrupt and return. 1468 * In the latter case, the interrupt might actually be meant for 1469 * someone else sharing this IRQ, and that driver will handle it. 1470 */ 1471 rev = GETPORT(REV); 1472 dmacntrl0 = GETPORT(DMACNTRL0); 1473 if ((rev == 0xFF) && (dmacntrl0 == 0xFF)) 1474 return IRQ_NONE; 1475 1476 /* no more interrupts from the controller, while we're busy. 1477 INTEN is restored by the BH handler */ 1478 CLRBITS(DMACNTRL0, INTEN); 1479 1480 #if 0 1481 /* check if there is already something to be 1482 serviced; should not happen */ 1483 if(HOSTDATA(shpnt)->service) { 1484 printk(KERN_ERR "aha152x%d: lost interrupt (%d)\n", HOSTNO, HOSTDATA(shpnt)->service); 1485 show_queues(shpnt); 1486 } 1487 #endif 1488 1489 /* Poke the BH handler */ 1490 HOSTDATA(shpnt)->service++; 1491 INIT_WORK(&aha152x_tq, (void *) run, NULL); 1492 schedule_work(&aha152x_tq); 1493 return IRQ_HANDLED; 1494 } 1495 1496 /* 1497 * busfree phase 1498 * - handle completition/disconnection/error of current command 1499 * - start selection for next command (if any) 1500 */ 1501 static void busfree_run(struct Scsi_Host *shpnt) 1502 { 1503 unsigned long flags; 1504 #if defined(AHA152X_STAT) 1505 int action=0; 1506 #endif 1507 1508 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 1509 SETPORT(SXFRCTL0, CH1); 1510 1511 SETPORT(SSTAT1, CLRBUSFREE); 1512 1513 if(CURRENT_SC) { 1514 #if defined(AHA152X_STAT) 1515 action++; 1516 #endif 1517 CURRENT_SC->SCp.phase &= ~syncneg; 1518 1519 if(CURRENT_SC->SCp.phase & completed) { 1520 /* target sent COMMAND COMPLETE */ 1521 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16)); 1522 1523 } else if(CURRENT_SC->SCp.phase & aborted) { 1524 DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC)); 1525 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16)); 1526 1527 } else if(CURRENT_SC->SCp.phase & resetted) { 1528 DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC)); 1529 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16)); 1530 1531 } else if(CURRENT_SC->SCp.phase & disconnected) { 1532 /* target sent DISCONNECT */ 1533 DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n", 1534 CMDINFO(CURRENT_SC), 1535 CURRENT_SC->resid, 1536 CURRENT_SC->request_bufflen); 1537 #if defined(AHA152X_STAT) 1538 HOSTDATA(shpnt)->disconnections++; 1539 #endif 1540 append_SC(&DISCONNECTED_SC, CURRENT_SC); 1541 CURRENT_SC->SCp.phase |= 1 << 16; 1542 CURRENT_SC = NULL; 1543 1544 } else { 1545 done(shpnt, DID_ERROR << 16); 1546 } 1547 #if defined(AHA152X_STAT) 1548 } else { 1549 HOSTDATA(shpnt)->busfree_without_old_command++; 1550 #endif 1551 } 1552 1553 DO_LOCK(flags); 1554 1555 if(DONE_SC) { 1556 #if defined(AHA152X_STAT) 1557 action++; 1558 #endif 1559 1560 if(DONE_SC->SCp.phase & check_condition) { 1561 #if 0 1562 if(HOSTDATA(shpnt)->debug & debug_eh) { 1563 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC)); 1564 scsi_print_sense("bh", DONE_SC); 1565 } 1566 #endif 1567 1568 /* restore old command */ 1569 memcpy((void *) DONE_SC->cmnd, (void *) DONE_SC->data_cmnd, sizeof(DONE_SC->data_cmnd)); 1570 DONE_SC->request_buffer = DONE_SC->buffer; 1571 DONE_SC->request_bufflen = DONE_SC->bufflen; 1572 DONE_SC->use_sg = DONE_SC->old_use_sg; 1573 DONE_SC->cmd_len = DONE_SC->old_cmd_len; 1574 1575 DONE_SC->SCp.Status = 0x02; 1576 1577 HOSTDATA(shpnt)->commands--; 1578 if (!HOSTDATA(shpnt)->commands) 1579 SETPORT(PORTA, 0); /* turn led off */ 1580 } else if(DONE_SC->SCp.Status==0x02) { 1581 #if defined(AHA152X_STAT) 1582 HOSTDATA(shpnt)->busfree_with_check_condition++; 1583 #endif 1584 #if 0 1585 DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC)); 1586 #endif 1587 1588 if(!(DONE_SC->SCp.Status & not_issued)) { 1589 Scsi_Cmnd *ptr = DONE_SC; 1590 DONE_SC=NULL; 1591 #if 0 1592 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr)); 1593 #endif 1594 1595 ptr->cmnd[0] = REQUEST_SENSE; 1596 ptr->cmnd[1] = 0; 1597 ptr->cmnd[2] = 0; 1598 ptr->cmnd[3] = 0; 1599 ptr->cmnd[4] = sizeof(ptr->sense_buffer); 1600 ptr->cmnd[5] = 0; 1601 ptr->cmd_len = 6; 1602 ptr->use_sg = 0; 1603 ptr->request_buffer = ptr->sense_buffer; 1604 ptr->request_bufflen = sizeof(ptr->sense_buffer); 1605 1606 DO_UNLOCK(flags); 1607 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done); 1608 DO_LOCK(flags); 1609 #if 0 1610 } else { 1611 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC)); 1612 #endif 1613 } 1614 } 1615 1616 if(DONE_SC && DONE_SC->scsi_done) { 1617 #if defined(AHA152X_DEBUG) 1618 int hostno=DONE_SC->device->host->host_no; 1619 int id=DONE_SC->device->id & 0xf; 1620 int lun=DONE_SC->device->lun & 0x7; 1621 #endif 1622 Scsi_Cmnd *ptr = DONE_SC; 1623 DONE_SC=NULL; 1624 1625 /* turn led off, when no commands are in the driver */ 1626 HOSTDATA(shpnt)->commands--; 1627 if (!HOSTDATA(shpnt)->commands) 1628 SETPORT(PORTA, 0); /* turn led off */ 1629 1630 if(ptr->scsi_done != reset_done) { 1631 kfree(ptr->host_scribble); 1632 ptr->host_scribble=NULL; 1633 } 1634 1635 DO_UNLOCK(flags); 1636 DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr); 1637 ptr->scsi_done(ptr); 1638 DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr); 1639 DO_LOCK(flags); 1640 } 1641 1642 DONE_SC=NULL; 1643 #if defined(AHA152X_STAT) 1644 } else { 1645 HOSTDATA(shpnt)->busfree_without_done_command++; 1646 #endif 1647 } 1648 1649 if(ISSUE_SC) 1650 CURRENT_SC = remove_first_SC(&ISSUE_SC); 1651 1652 DO_UNLOCK(flags); 1653 1654 if(CURRENT_SC) { 1655 #if defined(AHA152X_STAT) 1656 action++; 1657 #endif 1658 CURRENT_SC->SCp.phase |= selecting; 1659 1660 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC)); 1661 1662 /* clear selection timeout */ 1663 SETPORT(SSTAT1, SELTO); 1664 1665 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id); 1666 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER); 1667 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0)); 1668 } else { 1669 #if defined(AHA152X_STAT) 1670 HOSTDATA(shpnt)->busfree_without_new_command++; 1671 #endif 1672 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0); 1673 } 1674 1675 #if defined(AHA152X_STAT) 1676 if(!action) 1677 HOSTDATA(shpnt)->busfree_without_any_action++; 1678 #endif 1679 } 1680 1681 /* 1682 * Selection done (OUT) 1683 * - queue IDENTIFY message and SDTR to selected target for message out 1684 * (ATN asserted automagically via ENAUTOATNO in busfree()) 1685 */ 1686 static void seldo_run(struct Scsi_Host *shpnt) 1687 { 1688 SETPORT(SCSISIG, 0); 1689 SETPORT(SSTAT1, CLRBUSFREE); 1690 SETPORT(SSTAT1, CLRPHASECHG); 1691 1692 CURRENT_SC->SCp.phase &= ~(selecting|not_issued); 1693 1694 SETPORT(SCSISEQ, 0); 1695 1696 if (TESTLO(SSTAT0, SELDO)) { 1697 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC)); 1698 done(shpnt, DID_NO_CONNECT << 16); 1699 return; 1700 } 1701 1702 SETPORT(SSTAT0, CLRSELDO); 1703 1704 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun)); 1705 1706 if (CURRENT_SC->SCp.phase & aborting) { 1707 ADDMSGO(ABORT); 1708 } else if (CURRENT_SC->SCp.phase & resetting) { 1709 ADDMSGO(BUS_DEVICE_RESET); 1710 } else if (SYNCNEG==0 && SYNCHRONOUS) { 1711 CURRENT_SC->SCp.phase |= syncneg; 1712 ADDMSGO(EXTENDED_MESSAGE); 1713 ADDMSGO(3); 1714 ADDMSGO(EXTENDED_SDTR); 1715 ADDMSGO(50); /* 200ns */ 1716 ADDMSGO(8); /* 8 byte req/ack offset */ 1717 1718 SYNCNEG=1; /* negotiation in progress */ 1719 } 1720 1721 SETRATE(SYNCRATE); 1722 } 1723 1724 /* 1725 * Selection timeout 1726 * - return command to mid-level with failure cause 1727 * 1728 */ 1729 static void selto_run(struct Scsi_Host *shpnt) 1730 { 1731 SETPORT(SCSISEQ, 0); 1732 SETPORT(SSTAT1, CLRSELTIMO); 1733 1734 DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC)); 1735 1736 if(!CURRENT_SC) { 1737 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC)); 1738 return; 1739 } 1740 1741 CURRENT_SC->SCp.phase &= ~selecting; 1742 1743 if (CURRENT_SC->SCp.phase & aborted) { 1744 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC)); 1745 done(shpnt, DID_ABORT << 16); 1746 } else if (TESTLO(SSTAT0, SELINGO)) { 1747 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC)); 1748 done(shpnt, DID_BUS_BUSY << 16); 1749 } else { 1750 /* ARBITRATION won, but SELECTION failed */ 1751 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC)); 1752 done(shpnt, DID_NO_CONNECT << 16); 1753 } 1754 } 1755 1756 /* 1757 * Selection in done 1758 * - put current command back to issue queue 1759 * (reconnection of a disconnected nexus instead 1760 * of successful selection out) 1761 * 1762 */ 1763 static void seldi_run(struct Scsi_Host *shpnt) 1764 { 1765 int selid; 1766 int target; 1767 unsigned long flags; 1768 1769 SETPORT(SCSISIG, 0); 1770 SETPORT(SSTAT0, CLRSELDI); 1771 SETPORT(SSTAT1, CLRBUSFREE); 1772 SETPORT(SSTAT1, CLRPHASECHG); 1773 1774 if(CURRENT_SC) { 1775 if(!(CURRENT_SC->SCp.phase & not_issued)) 1776 printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC)); 1777 1778 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC)); 1779 1780 DO_LOCK(flags); 1781 append_SC(&ISSUE_SC, CURRENT_SC); 1782 DO_UNLOCK(flags); 1783 1784 CURRENT_SC = NULL; 1785 } 1786 1787 if(!DISCONNECTED_SC) { 1788 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC)); 1789 return; 1790 } 1791 1792 RECONN_TARGET=-1; 1793 1794 selid = GETPORT(SELID) & ~(1 << shpnt->this_id); 1795 1796 if (selid==0) { 1797 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid); 1798 return; 1799 } 1800 1801 for(target=7; !(selid & (1 << target)); target--) 1802 ; 1803 1804 if(selid & ~(1 << target)) { 1805 printk("aha152x%d: multiple targets reconnected (%02x)\n", 1806 HOSTNO, selid); 1807 } 1808 1809 1810 SETPORT(SCSIID, (shpnt->this_id << OID_) | target); 1811 SETPORT(SCSISEQ, 0); 1812 1813 SETRATE(HOSTDATA(shpnt)->syncrate[target]); 1814 1815 RECONN_TARGET=target; 1816 DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid); 1817 } 1818 1819 /* 1820 * message in phase 1821 * - handle initial message after reconnection to identify 1822 * reconnecting nexus 1823 * - queue command on DISCONNECTED_SC on DISCONNECT message 1824 * - set completed flag on COMMAND COMPLETE 1825 * (other completition code moved to busfree_run) 1826 * - handle response to SDTR 1827 * - clear synchronous transfer agreements on BUS RESET 1828 * 1829 * FIXME: what about SAVE POINTERS, RESTORE POINTERS? 1830 * 1831 */ 1832 static void msgi_run(struct Scsi_Host *shpnt) 1833 { 1834 for(;;) { 1835 int sstat1 = GETPORT(SSTAT1); 1836 1837 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT)) 1838 return; 1839 1840 if(TESTLO(SSTAT0,SPIORDY)) { 1841 DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC)); 1842 return; 1843 } 1844 1845 ADDMSGI(GETPORT(SCSIDAT)); 1846 1847 #if defined(AHA152X_DEBUG) 1848 if (HOSTDATA(shpnt)->debug & debug_msgi) { 1849 printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0)); 1850 scsi_print_msg(&MSGI(0)); 1851 printk("\n"); 1852 } 1853 #endif 1854 1855 if(!CURRENT_SC) { 1856 if(LASTSTATE!=seldi) { 1857 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO); 1858 } 1859 1860 /* 1861 * Handle reselection 1862 */ 1863 if(!(MSGI(0) & IDENTIFY_BASE)) { 1864 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO); 1865 continue; 1866 } 1867 1868 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f); 1869 1870 if (!CURRENT_SC) { 1871 show_queues(shpnt); 1872 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f); 1873 continue; 1874 } 1875 1876 DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC)); 1877 1878 CURRENT_SC->SCp.Message = MSGI(0); 1879 CURRENT_SC->SCp.phase &= ~disconnected; 1880 1881 MSGILEN=0; 1882 1883 /* next message if any */ 1884 continue; 1885 } 1886 1887 CURRENT_SC->SCp.Message = MSGI(0); 1888 1889 switch (MSGI(0)) { 1890 case DISCONNECT: 1891 if (!RECONNECT) 1892 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC)); 1893 1894 CURRENT_SC->SCp.phase |= disconnected; 1895 break; 1896 1897 case COMMAND_COMPLETE: 1898 if(CURRENT_SC->SCp.phase & completed) 1899 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC)); 1900 1901 CURRENT_SC->SCp.phase |= completed; 1902 break; 1903 1904 case MESSAGE_REJECT: 1905 if (SYNCNEG==1) { 1906 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC)); 1907 SYNCNEG=2; /* negotiation completed */ 1908 } else 1909 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC)); 1910 break; 1911 1912 case SAVE_POINTERS: 1913 break; 1914 1915 case RESTORE_POINTERS: 1916 break; 1917 1918 case EXTENDED_MESSAGE: 1919 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) { 1920 /* not yet completed */ 1921 continue; 1922 } 1923 1924 switch (MSGI(2)) { 1925 case EXTENDED_SDTR: 1926 { 1927 long ticks; 1928 1929 if (MSGI(1) != 3) { 1930 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC)); 1931 break; 1932 } 1933 1934 if (!HOSTDATA(shpnt)->synchronous) 1935 break; 1936 1937 printk(INFO_LEAD, CMDINFO(CURRENT_SC)); 1938 scsi_print_msg(&MSGI(0)); 1939 printk("\n"); 1940 1941 ticks = (MSGI(3) * 4 + 49) / 50; 1942 1943 if (syncneg) { 1944 /* negotiation in progress */ 1945 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) { 1946 ADDMSGO(MESSAGE_REJECT); 1947 printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC)); 1948 break; 1949 } 1950 1951 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4); 1952 } else if (ticks <= 9 && MSGI(4) >= 1) { 1953 ADDMSGO(EXTENDED_MESSAGE); 1954 ADDMSGO(3); 1955 ADDMSGO(EXTENDED_SDTR); 1956 if (ticks < 4) { 1957 ticks = 4; 1958 ADDMSGO(50); 1959 } else 1960 ADDMSGO(MSGI(3)); 1961 1962 if (MSGI(4) > 8) 1963 MSGI(4) = 8; 1964 1965 ADDMSGO(MSGI(4)); 1966 1967 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4); 1968 } else { 1969 /* requested SDTR is too slow, do it asynchronously */ 1970 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC)); 1971 ADDMSGO(MESSAGE_REJECT); 1972 } 1973 1974 SYNCNEG=2; /* negotiation completed */ 1975 SETRATE(SYNCRATE); 1976 } 1977 break; 1978 1979 case BUS_DEVICE_RESET: 1980 { 1981 int i; 1982 1983 for(i=0; i<8; i++) { 1984 HOSTDATA(shpnt)->syncrate[i]=0; 1985 HOSTDATA(shpnt)->syncneg[i]=0; 1986 } 1987 1988 } 1989 break; 1990 1991 case EXTENDED_MODIFY_DATA_POINTER: 1992 case EXTENDED_EXTENDED_IDENTIFY: 1993 case EXTENDED_WDTR: 1994 default: 1995 ADDMSGO(MESSAGE_REJECT); 1996 break; 1997 } 1998 break; 1999 } 2000 2001 MSGILEN=0; 2002 } 2003 } 2004 2005 static void msgi_end(struct Scsi_Host *shpnt) 2006 { 2007 if(MSGILEN>0) 2008 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN); 2009 2010 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) { 2011 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC)); 2012 SETPORT(SCSISIG, P_MSGI | SIG_ATNO); 2013 } 2014 } 2015 2016 /* 2017 * message out phase 2018 * 2019 */ 2020 static void msgo_init(struct Scsi_Host *shpnt) 2021 { 2022 if(MSGOLEN==0) { 2023 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) { 2024 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun)); 2025 } else { 2026 printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC)); 2027 ADDMSGO(MESSAGE_REJECT); 2028 } 2029 } 2030 2031 #if defined(AHA152X_DEBUG) 2032 if(HOSTDATA(shpnt)->debug & debug_msgo) { 2033 int i; 2034 2035 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC)); 2036 for (i=0; i<MSGOLEN; i+=scsi_print_msg(&MSGO(i)), printk(" ")) 2037 ; 2038 printk(")\n"); 2039 } 2040 #endif 2041 } 2042 2043 /* 2044 * message out phase 2045 * 2046 */ 2047 static void msgo_run(struct Scsi_Host *shpnt) 2048 { 2049 if(MSGO_I==MSGOLEN) 2050 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN); 2051 2052 while(MSGO_I<MSGOLEN) { 2053 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN); 2054 2055 if(TESTLO(SSTAT0, SPIORDY)) { 2056 DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC)); 2057 return; 2058 } 2059 2060 if (MSGO_I==MSGOLEN-1) { 2061 /* Leave MESSAGE OUT after transfer */ 2062 SETPORT(SSTAT1, CLRATNO); 2063 } 2064 2065 2066 if (MSGO(MSGO_I) & IDENTIFY_BASE) 2067 CURRENT_SC->SCp.phase |= identified; 2068 2069 if (MSGO(MSGO_I)==ABORT) 2070 CURRENT_SC->SCp.phase |= aborted; 2071 2072 if (MSGO(MSGO_I)==BUS_DEVICE_RESET) 2073 CURRENT_SC->SCp.phase |= resetted; 2074 2075 SETPORT(SCSIDAT, MSGO(MSGO_I++)); 2076 } 2077 } 2078 2079 static void msgo_end(struct Scsi_Host *shpnt) 2080 { 2081 if(MSGO_I<MSGOLEN) { 2082 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN); 2083 if(SYNCNEG==1) { 2084 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC)); 2085 SYNCNEG=2; 2086 } 2087 } 2088 2089 MSGO_I = 0; 2090 MSGOLEN = 0; 2091 } 2092 2093 /* 2094 * command phase 2095 * 2096 */ 2097 static void cmd_init(struct Scsi_Host *shpnt) 2098 { 2099 if (CURRENT_SC->SCp.sent_command) { 2100 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC)); 2101 done(shpnt, DID_ERROR << 16); 2102 return; 2103 } 2104 2105 #if defined(AHA152X_DEBUG) 2106 if (HOSTDATA(shpnt)->debug & debug_cmd) { 2107 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC)); 2108 __scsi_print_command(CURRENT_SC->cmnd); 2109 } 2110 #endif 2111 2112 CMD_I=0; 2113 } 2114 2115 /* 2116 * command phase 2117 * 2118 */ 2119 static void cmd_run(struct Scsi_Host *shpnt) 2120 { 2121 if(CMD_I==CURRENT_SC->cmd_len) { 2122 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len); 2123 disp_ports(shpnt); 2124 } 2125 2126 while(CMD_I<CURRENT_SC->cmd_len) { 2127 DPRINTK(debug_cmd, DEBUG_LEAD "command byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), CURRENT_SC->cmnd[CMD_I], CMD_I, CURRENT_SC->cmd_len); 2128 2129 if(TESTLO(SSTAT0, SPIORDY)) { 2130 DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC)); 2131 return; 2132 } 2133 2134 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]); 2135 } 2136 } 2137 2138 static void cmd_end(struct Scsi_Host *shpnt) 2139 { 2140 if(CMD_I<CURRENT_SC->cmd_len) 2141 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len); 2142 else 2143 CURRENT_SC->SCp.sent_command++; 2144 } 2145 2146 /* 2147 * status phase 2148 * 2149 */ 2150 static void status_run(struct Scsi_Host *shpnt) 2151 { 2152 if(TESTLO(SSTAT0,SPIORDY)) { 2153 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC)); 2154 return; 2155 } 2156 2157 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT); 2158 2159 #if defined(AHA152X_DEBUG) 2160 if (HOSTDATA(shpnt)->debug & debug_status) { 2161 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status); 2162 scsi_print_status(CURRENT_SC->SCp.Status); 2163 printk("\n"); 2164 } 2165 #endif 2166 } 2167 2168 /* 2169 * data in phase 2170 * 2171 */ 2172 static void datai_init(struct Scsi_Host *shpnt) 2173 { 2174 SETPORT(DMACNTRL0, RSTFIFO); 2175 SETPORT(DMACNTRL0, RSTFIFO|ENDMA); 2176 2177 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 2178 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN); 2179 2180 SETPORT(SIMODE0, 0); 2181 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE); 2182 2183 DATA_LEN=0; 2184 DPRINTK(debug_datai, 2185 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n", 2186 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid); 2187 } 2188 2189 static void datai_run(struct Scsi_Host *shpnt) 2190 { 2191 unsigned long the_time; 2192 int fifodata, data_count; 2193 2194 /* 2195 * loop while the phase persists or the fifos are not empty 2196 * 2197 */ 2198 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) { 2199 /* FIXME: maybe this should be done by setting up 2200 * STCNT to trigger ENSWRAP interrupt, instead of 2201 * polling for DFIFOFULL 2202 */ 2203 the_time=jiffies + 100*HZ; 2204 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time)) 2205 barrier(); 2206 2207 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) { 2208 printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC)); 2209 disp_ports(shpnt); 2210 break; 2211 } 2212 2213 if(TESTHI(DMASTAT, DFIFOFULL)) { 2214 fifodata = 128; 2215 } else { 2216 the_time=jiffies + 100*HZ; 2217 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time)) 2218 barrier(); 2219 2220 if(TESTLO(SSTAT2, SEMPTY)) { 2221 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC)); 2222 disp_ports(shpnt); 2223 break; 2224 } 2225 2226 fifodata = GETPORT(FIFOSTAT); 2227 } 2228 2229 if(CURRENT_SC->SCp.this_residual>0) { 2230 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) { 2231 data_count = fifodata>CURRENT_SC->SCp.this_residual ? 2232 CURRENT_SC->SCp.this_residual : 2233 fifodata; 2234 fifodata -= data_count; 2235 2236 if(data_count & 1) { 2237 DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC)); 2238 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2239 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT); 2240 CURRENT_SC->SCp.this_residual--; 2241 DATA_LEN++; 2242 SETPORT(DMACNTRL0, ENDMA); 2243 } 2244 2245 if(data_count > 1) { 2246 DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count); 2247 data_count >>= 1; 2248 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count); 2249 CURRENT_SC->SCp.ptr += 2 * data_count; 2250 CURRENT_SC->SCp.this_residual -= 2 * data_count; 2251 DATA_LEN += 2 * data_count; 2252 } 2253 2254 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) { 2255 /* advance to next buffer */ 2256 CURRENT_SC->SCp.buffers_residual--; 2257 CURRENT_SC->SCp.buffer++; 2258 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer); 2259 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length; 2260 } 2261 } 2262 } else if(fifodata>0) { 2263 printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT)); 2264 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2265 while(fifodata>0) { 2266 int data; 2267 data=GETPORT(DATAPORT); 2268 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data); 2269 fifodata--; 2270 DATA_LEN++; 2271 } 2272 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2273 } 2274 } 2275 2276 if(TESTLO(DMASTAT, INTSTAT) || 2277 TESTLO(DMASTAT, DFIFOEMP) || 2278 TESTLO(SSTAT2, SEMPTY) || 2279 GETPORT(FIFOSTAT)>0) { 2280 /* 2281 * something went wrong, if there's something left in the fifos 2282 * or the phase didn't change 2283 */ 2284 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC)); 2285 disp_ports(shpnt); 2286 } 2287 2288 if(DATA_LEN!=GETSTCNT()) { 2289 printk(ERR_LEAD 2290 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)", 2291 CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT)); 2292 disp_ports(shpnt); 2293 mdelay(10000); 2294 } 2295 } 2296 2297 static void datai_end(struct Scsi_Host *shpnt) 2298 { 2299 CURRENT_SC->resid -= GETSTCNT(); 2300 2301 DPRINTK(debug_datai, 2302 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n", 2303 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid, GETSTCNT()); 2304 2305 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 2306 SETPORT(DMACNTRL0, 0); 2307 } 2308 2309 /* 2310 * data out phase 2311 * 2312 */ 2313 static void datao_init(struct Scsi_Host *shpnt) 2314 { 2315 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO); 2316 SETPORT(DMACNTRL0, WRITE_READ | ENDMA); 2317 2318 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 2319 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN); 2320 2321 SETPORT(SIMODE0, 0); 2322 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE ); 2323 2324 DATA_LEN = CURRENT_SC->resid; 2325 2326 DPRINTK(debug_datao, 2327 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n", 2328 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid); 2329 } 2330 2331 static void datao_run(struct Scsi_Host *shpnt) 2332 { 2333 unsigned long the_time; 2334 int data_count; 2335 2336 /* until phase changes or all data sent */ 2337 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) { 2338 data_count = 128; 2339 if(data_count > CURRENT_SC->SCp.this_residual) 2340 data_count=CURRENT_SC->SCp.this_residual; 2341 2342 if(TESTLO(DMASTAT, DFIFOEMP)) { 2343 printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT)); 2344 disp_ports(shpnt); 2345 break; 2346 } 2347 2348 if(data_count & 1) { 2349 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT); 2350 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++); 2351 CURRENT_SC->SCp.this_residual--; 2352 CURRENT_SC->resid--; 2353 SETPORT(DMACNTRL0,WRITE_READ|ENDMA); 2354 } 2355 2356 if(data_count > 1) { 2357 data_count >>= 1; 2358 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count); 2359 CURRENT_SC->SCp.ptr += 2 * data_count; 2360 CURRENT_SC->SCp.this_residual -= 2 * data_count; 2361 CURRENT_SC->resid -= 2 * data_count; 2362 } 2363 2364 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) { 2365 /* advance to next buffer */ 2366 CURRENT_SC->SCp.buffers_residual--; 2367 CURRENT_SC->SCp.buffer++; 2368 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer); 2369 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length; 2370 } 2371 2372 the_time=jiffies + 100*HZ; 2373 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time)) 2374 barrier(); 2375 2376 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) { 2377 printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC)); 2378 disp_ports(shpnt); 2379 break; 2380 } 2381 } 2382 } 2383 2384 static void datao_end(struct Scsi_Host *shpnt) 2385 { 2386 if(TESTLO(DMASTAT, DFIFOEMP)) { 2387 int data_count = (DATA_LEN - CURRENT_SC->resid) - GETSTCNT(); 2388 2389 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n", 2390 CMDINFO(CURRENT_SC), 2391 data_count, 2392 DATA_LEN-CURRENT_SC->resid, 2393 GETSTCNT()); 2394 2395 CURRENT_SC->resid += data_count; 2396 2397 if(CURRENT_SC->use_sg) { 2398 data_count -= CURRENT_SC->SCp.ptr - SG_ADDRESS(CURRENT_SC->SCp.buffer); 2399 while(data_count>0) { 2400 CURRENT_SC->SCp.buffer--; 2401 CURRENT_SC->SCp.buffers_residual++; 2402 data_count -= CURRENT_SC->SCp.buffer->length; 2403 } 2404 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) - data_count; 2405 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + data_count; 2406 } else { 2407 CURRENT_SC->SCp.ptr -= data_count; 2408 CURRENT_SC->SCp.this_residual += data_count; 2409 } 2410 } 2411 2412 DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n", 2413 CMDINFO(CURRENT_SC), 2414 CURRENT_SC->request_bufflen, 2415 CURRENT_SC->resid, 2416 GETSTCNT()); 2417 2418 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 2419 SETPORT(SXFRCTL0, CH1); 2420 2421 SETPORT(DMACNTRL0, 0); 2422 } 2423 2424 /* 2425 * figure out what state we're in 2426 * 2427 */ 2428 static int update_state(struct Scsi_Host *shpnt) 2429 { 2430 int dataphase=0; 2431 unsigned int stat0 = GETPORT(SSTAT0); 2432 unsigned int stat1 = GETPORT(SSTAT1); 2433 2434 PREVSTATE = STATE; 2435 STATE=unknown; 2436 2437 if(stat1 & SCSIRSTI) { 2438 STATE=rsti; 2439 SETPORT(SCSISEQ,0); 2440 SETPORT(SSTAT1,SCSIRSTI); 2441 } else if(stat0 & SELDI && PREVSTATE==busfree) { 2442 STATE=seldi; 2443 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) { 2444 STATE=seldo; 2445 } else if(stat1 & SELTO) { 2446 STATE=selto; 2447 } else if(stat1 & BUSFREE) { 2448 STATE=busfree; 2449 SETPORT(SSTAT1,BUSFREE); 2450 } else if(stat1 & SCSIPERR) { 2451 STATE=parerr; 2452 SETPORT(SSTAT1,SCSIPERR); 2453 } else if(stat1 & REQINIT) { 2454 switch(GETPORT(SCSISIG) & P_MASK) { 2455 case P_MSGI: STATE=msgi; break; 2456 case P_MSGO: STATE=msgo; break; 2457 case P_DATAO: STATE=datao; break; 2458 case P_DATAI: STATE=datai; break; 2459 case P_STATUS: STATE=status; break; 2460 case P_CMD: STATE=cmd; break; 2461 } 2462 dataphase=1; 2463 } 2464 2465 if((stat0 & SELDI) && STATE!=seldi && !dataphase) { 2466 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC)); 2467 disp_ports(shpnt); 2468 } 2469 2470 if(STATE!=PREVSTATE) { 2471 LASTSTATE=PREVSTATE; 2472 } 2473 2474 return dataphase; 2475 } 2476 2477 /* 2478 * handle parity error 2479 * 2480 * FIXME: in which phase? 2481 * 2482 */ 2483 static void parerr_run(struct Scsi_Host *shpnt) 2484 { 2485 printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC)); 2486 done(shpnt, DID_PARITY << 16); 2487 } 2488 2489 /* 2490 * handle reset in 2491 * 2492 */ 2493 static void rsti_run(struct Scsi_Host *shpnt) 2494 { 2495 Scsi_Cmnd *ptr; 2496 2497 printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO); 2498 2499 ptr=DISCONNECTED_SC; 2500 while(ptr) { 2501 Scsi_Cmnd *next = SCNEXT(ptr); 2502 2503 if (!ptr->device->soft_reset) { 2504 remove_SC(&DISCONNECTED_SC, ptr); 2505 2506 kfree(ptr->host_scribble); 2507 ptr->host_scribble=NULL; 2508 2509 ptr->result = DID_RESET << 16; 2510 ptr->scsi_done(ptr); 2511 } 2512 2513 ptr = next; 2514 } 2515 2516 if(CURRENT_SC && !CURRENT_SC->device->soft_reset) 2517 done(shpnt, DID_RESET << 16 ); 2518 } 2519 2520 2521 /* 2522 * bottom-half handler 2523 * 2524 */ 2525 static void is_complete(struct Scsi_Host *shpnt) 2526 { 2527 int dataphase; 2528 unsigned long flags; 2529 int pending; 2530 2531 DO_LOCK(flags); 2532 if(HOSTDATA(shpnt)->in_intr) { 2533 DO_UNLOCK(flags); 2534 /* aha152x_error never returns.. */ 2535 aha152x_error(shpnt, "bottom-half already running!?"); 2536 } 2537 HOSTDATA(shpnt)->in_intr++; 2538 2539 /* 2540 * loop while there are interrupt conditions pending 2541 * 2542 */ 2543 do { 2544 unsigned long start = jiffies; 2545 DO_UNLOCK(flags); 2546 2547 dataphase=update_state(shpnt); 2548 2549 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name); 2550 2551 /* 2552 * end previous state 2553 * 2554 */ 2555 if(PREVSTATE!=STATE && states[PREVSTATE].end) 2556 states[PREVSTATE].end(shpnt); 2557 2558 /* 2559 * disable SPIO mode if previous phase used it 2560 * and this one doesn't 2561 * 2562 */ 2563 if(states[PREVSTATE].spio && !states[STATE].spio) { 2564 SETPORT(SXFRCTL0, CH1); 2565 SETPORT(DMACNTRL0, 0); 2566 if(CURRENT_SC) 2567 CURRENT_SC->SCp.phase &= ~spiordy; 2568 } 2569 2570 /* 2571 * accept current dataphase phase 2572 * 2573 */ 2574 if(dataphase) { 2575 SETPORT(SSTAT0, REQINIT); 2576 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK); 2577 SETPORT(SSTAT1, PHASECHG); 2578 } 2579 2580 /* 2581 * enable SPIO mode if previous didn't use it 2582 * and this one does 2583 * 2584 */ 2585 if(!states[PREVSTATE].spio && states[STATE].spio) { 2586 SETPORT(DMACNTRL0, 0); 2587 SETPORT(SXFRCTL0, CH1|SPIOEN); 2588 if(CURRENT_SC) 2589 CURRENT_SC->SCp.phase |= spiordy; 2590 } 2591 2592 /* 2593 * initialize for new state 2594 * 2595 */ 2596 if(PREVSTATE!=STATE && states[STATE].init) 2597 states[STATE].init(shpnt); 2598 2599 /* 2600 * handle current state 2601 * 2602 */ 2603 if(states[STATE].run) 2604 states[STATE].run(shpnt); 2605 else 2606 printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE); 2607 2608 /* 2609 * setup controller to interrupt on 2610 * the next expected condition and 2611 * loop if it's already there 2612 * 2613 */ 2614 DO_LOCK(flags); 2615 pending=setup_expected_interrupts(shpnt); 2616 #if defined(AHA152X_STAT) 2617 HOSTDATA(shpnt)->count[STATE]++; 2618 if(PREVSTATE!=STATE) 2619 HOSTDATA(shpnt)->count_trans[STATE]++; 2620 HOSTDATA(shpnt)->time[STATE] += jiffies-start; 2621 #endif 2622 2623 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name); 2624 } while(pending); 2625 2626 /* 2627 * enable interrupts and leave bottom-half 2628 * 2629 */ 2630 HOSTDATA(shpnt)->in_intr--; 2631 SETBITS(DMACNTRL0, INTEN); 2632 DO_UNLOCK(flags); 2633 } 2634 2635 2636 /* 2637 * Dump the current driver status and panic 2638 */ 2639 static void aha152x_error(struct Scsi_Host *shpnt, char *msg) 2640 { 2641 printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg); 2642 show_queues(shpnt); 2643 panic("aha152x panic\n"); 2644 } 2645 2646 /* 2647 * Display registers of AIC-6260 2648 */ 2649 static void disp_ports(struct Scsi_Host *shpnt) 2650 { 2651 #if defined(AHA152X_DEBUG) 2652 int s; 2653 2654 printk("\n%s: %s(%s) ", 2655 CURRENT_SC ? "busy" : "waiting", 2656 states[STATE].name, 2657 states[PREVSTATE].name); 2658 2659 s = GETPORT(SCSISEQ); 2660 printk("SCSISEQ( "); 2661 if (s & TEMODEO) 2662 printk("TARGET MODE "); 2663 if (s & ENSELO) 2664 printk("SELO "); 2665 if (s & ENSELI) 2666 printk("SELI "); 2667 if (s & ENRESELI) 2668 printk("RESELI "); 2669 if (s & ENAUTOATNO) 2670 printk("AUTOATNO "); 2671 if (s & ENAUTOATNI) 2672 printk("AUTOATNI "); 2673 if (s & ENAUTOATNP) 2674 printk("AUTOATNP "); 2675 if (s & SCSIRSTO) 2676 printk("SCSIRSTO "); 2677 printk(");"); 2678 2679 printk(" SCSISIG("); 2680 s = GETPORT(SCSISIG); 2681 switch (s & P_MASK) { 2682 case P_DATAO: 2683 printk("DATA OUT"); 2684 break; 2685 case P_DATAI: 2686 printk("DATA IN"); 2687 break; 2688 case P_CMD: 2689 printk("COMMAND"); 2690 break; 2691 case P_STATUS: 2692 printk("STATUS"); 2693 break; 2694 case P_MSGO: 2695 printk("MESSAGE OUT"); 2696 break; 2697 case P_MSGI: 2698 printk("MESSAGE IN"); 2699 break; 2700 default: 2701 printk("*invalid*"); 2702 break; 2703 } 2704 2705 printk("); "); 2706 2707 printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo"); 2708 2709 printk("SSTAT( "); 2710 s = GETPORT(SSTAT0); 2711 if (s & TARGET) 2712 printk("TARGET "); 2713 if (s & SELDO) 2714 printk("SELDO "); 2715 if (s & SELDI) 2716 printk("SELDI "); 2717 if (s & SELINGO) 2718 printk("SELINGO "); 2719 if (s & SWRAP) 2720 printk("SWRAP "); 2721 if (s & SDONE) 2722 printk("SDONE "); 2723 if (s & SPIORDY) 2724 printk("SPIORDY "); 2725 if (s & DMADONE) 2726 printk("DMADONE "); 2727 2728 s = GETPORT(SSTAT1); 2729 if (s & SELTO) 2730 printk("SELTO "); 2731 if (s & ATNTARG) 2732 printk("ATNTARG "); 2733 if (s & SCSIRSTI) 2734 printk("SCSIRSTI "); 2735 if (s & PHASEMIS) 2736 printk("PHASEMIS "); 2737 if (s & BUSFREE) 2738 printk("BUSFREE "); 2739 if (s & SCSIPERR) 2740 printk("SCSIPERR "); 2741 if (s & PHASECHG) 2742 printk("PHASECHG "); 2743 if (s & REQINIT) 2744 printk("REQINIT "); 2745 printk("); "); 2746 2747 2748 printk("SSTAT( "); 2749 2750 s = GETPORT(SSTAT0) & GETPORT(SIMODE0); 2751 2752 if (s & TARGET) 2753 printk("TARGET "); 2754 if (s & SELDO) 2755 printk("SELDO "); 2756 if (s & SELDI) 2757 printk("SELDI "); 2758 if (s & SELINGO) 2759 printk("SELINGO "); 2760 if (s & SWRAP) 2761 printk("SWRAP "); 2762 if (s & SDONE) 2763 printk("SDONE "); 2764 if (s & SPIORDY) 2765 printk("SPIORDY "); 2766 if (s & DMADONE) 2767 printk("DMADONE "); 2768 2769 s = GETPORT(SSTAT1) & GETPORT(SIMODE1); 2770 2771 if (s & SELTO) 2772 printk("SELTO "); 2773 if (s & ATNTARG) 2774 printk("ATNTARG "); 2775 if (s & SCSIRSTI) 2776 printk("SCSIRSTI "); 2777 if (s & PHASEMIS) 2778 printk("PHASEMIS "); 2779 if (s & BUSFREE) 2780 printk("BUSFREE "); 2781 if (s & SCSIPERR) 2782 printk("SCSIPERR "); 2783 if (s & PHASECHG) 2784 printk("PHASECHG "); 2785 if (s & REQINIT) 2786 printk("REQINIT "); 2787 printk("); "); 2788 2789 printk("SXFRCTL0( "); 2790 2791 s = GETPORT(SXFRCTL0); 2792 if (s & SCSIEN) 2793 printk("SCSIEN "); 2794 if (s & DMAEN) 2795 printk("DMAEN "); 2796 if (s & CH1) 2797 printk("CH1 "); 2798 if (s & CLRSTCNT) 2799 printk("CLRSTCNT "); 2800 if (s & SPIOEN) 2801 printk("SPIOEN "); 2802 if (s & CLRCH1) 2803 printk("CLRCH1 "); 2804 printk("); "); 2805 2806 printk("SIGNAL( "); 2807 2808 s = GETPORT(SCSISIG); 2809 if (s & SIG_ATNI) 2810 printk("ATNI "); 2811 if (s & SIG_SELI) 2812 printk("SELI "); 2813 if (s & SIG_BSYI) 2814 printk("BSYI "); 2815 if (s & SIG_REQI) 2816 printk("REQI "); 2817 if (s & SIG_ACKI) 2818 printk("ACKI "); 2819 printk("); "); 2820 2821 printk("SELID (%02x), ", GETPORT(SELID)); 2822 2823 printk("STCNT (%d), ", GETSTCNT()); 2824 2825 printk("SSTAT2( "); 2826 2827 s = GETPORT(SSTAT2); 2828 if (s & SOFFSET) 2829 printk("SOFFSET "); 2830 if (s & SEMPTY) 2831 printk("SEMPTY "); 2832 if (s & SFULL) 2833 printk("SFULL "); 2834 printk("); SFCNT (%d); ", s & (SFULL | SFCNT)); 2835 2836 s = GETPORT(SSTAT3); 2837 printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f); 2838 2839 printk("SSTAT4( "); 2840 s = GETPORT(SSTAT4); 2841 if (s & SYNCERR) 2842 printk("SYNCERR "); 2843 if (s & FWERR) 2844 printk("FWERR "); 2845 if (s & FRERR) 2846 printk("FRERR "); 2847 printk("); "); 2848 2849 printk("DMACNTRL0( "); 2850 s = GETPORT(DMACNTRL0); 2851 printk("%s ", s & _8BIT ? "8BIT" : "16BIT"); 2852 printk("%s ", s & DMA ? "DMA" : "PIO"); 2853 printk("%s ", s & WRITE_READ ? "WRITE" : "READ"); 2854 if (s & ENDMA) 2855 printk("ENDMA "); 2856 if (s & INTEN) 2857 printk("INTEN "); 2858 if (s & RSTFIFO) 2859 printk("RSTFIFO "); 2860 if (s & SWINT) 2861 printk("SWINT "); 2862 printk("); "); 2863 2864 printk("DMASTAT( "); 2865 s = GETPORT(DMASTAT); 2866 if (s & ATDONE) 2867 printk("ATDONE "); 2868 if (s & WORDRDY) 2869 printk("WORDRDY "); 2870 if (s & DFIFOFULL) 2871 printk("DFIFOFULL "); 2872 if (s & DFIFOEMP) 2873 printk("DFIFOEMP "); 2874 printk(")\n"); 2875 #endif 2876 } 2877 2878 /* 2879 * display enabled interrupts 2880 */ 2881 static void disp_enintr(struct Scsi_Host *shpnt) 2882 { 2883 int s; 2884 2885 printk(KERN_DEBUG "enabled interrupts ( "); 2886 2887 s = GETPORT(SIMODE0); 2888 if (s & ENSELDO) 2889 printk("ENSELDO "); 2890 if (s & ENSELDI) 2891 printk("ENSELDI "); 2892 if (s & ENSELINGO) 2893 printk("ENSELINGO "); 2894 if (s & ENSWRAP) 2895 printk("ENSWRAP "); 2896 if (s & ENSDONE) 2897 printk("ENSDONE "); 2898 if (s & ENSPIORDY) 2899 printk("ENSPIORDY "); 2900 if (s & ENDMADONE) 2901 printk("ENDMADONE "); 2902 2903 s = GETPORT(SIMODE1); 2904 if (s & ENSELTIMO) 2905 printk("ENSELTIMO "); 2906 if (s & ENATNTARG) 2907 printk("ENATNTARG "); 2908 if (s & ENPHASEMIS) 2909 printk("ENPHASEMIS "); 2910 if (s & ENBUSFREE) 2911 printk("ENBUSFREE "); 2912 if (s & ENSCSIPERR) 2913 printk("ENSCSIPERR "); 2914 if (s & ENPHASECHG) 2915 printk("ENPHASECHG "); 2916 if (s & ENREQINIT) 2917 printk("ENREQINIT "); 2918 printk(")\n"); 2919 } 2920 2921 /* 2922 * Show the command data of a command 2923 */ 2924 static void show_command(Scsi_Cmnd *ptr) 2925 { 2926 printk(KERN_DEBUG "0x%08x: target=%d; lun=%d; cmnd=(", 2927 (unsigned int) ptr, ptr->device->id, ptr->device->lun); 2928 2929 __scsi_print_command(ptr->cmnd); 2930 2931 printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |", 2932 ptr->request_bufflen, ptr->resid); 2933 2934 if (ptr->SCp.phase & not_issued) 2935 printk("not issued|"); 2936 if (ptr->SCp.phase & selecting) 2937 printk("selecting|"); 2938 if (ptr->SCp.phase & identified) 2939 printk("identified|"); 2940 if (ptr->SCp.phase & disconnected) 2941 printk("disconnected|"); 2942 if (ptr->SCp.phase & completed) 2943 printk("completed|"); 2944 if (ptr->SCp.phase & spiordy) 2945 printk("spiordy|"); 2946 if (ptr->SCp.phase & syncneg) 2947 printk("syncneg|"); 2948 if (ptr->SCp.phase & aborted) 2949 printk("aborted|"); 2950 if (ptr->SCp.phase & resetted) 2951 printk("resetted|"); 2952 if( SCDATA(ptr) ) { 2953 printk("; next=0x%p\n", SCNEXT(ptr)); 2954 } else { 2955 printk("; next=(host scribble NULL)\n"); 2956 } 2957 } 2958 2959 /* 2960 * Dump the queued data 2961 */ 2962 static void show_queues(struct Scsi_Host *shpnt) 2963 { 2964 Scsi_Cmnd *ptr; 2965 unsigned long flags; 2966 2967 DO_LOCK(flags); 2968 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n"); 2969 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr)) 2970 show_command(ptr); 2971 DO_UNLOCK(flags); 2972 2973 printk(KERN_DEBUG "current_SC:\n"); 2974 if (CURRENT_SC) 2975 show_command(CURRENT_SC); 2976 else 2977 printk(KERN_DEBUG "none\n"); 2978 2979 printk(KERN_DEBUG "disconnected_SC:\n"); 2980 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL) 2981 show_command(ptr); 2982 2983 disp_ports(shpnt); 2984 disp_enintr(shpnt); 2985 } 2986 2987 #undef SPRINTF 2988 #define SPRINTF(args...) pos += sprintf(pos, ## args) 2989 2990 static int get_command(char *pos, Scsi_Cmnd * ptr) 2991 { 2992 char *start = pos; 2993 int i; 2994 2995 SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ", 2996 (unsigned int) ptr, ptr->device->id, ptr->device->lun); 2997 2998 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++) 2999 SPRINTF("0x%02x ", ptr->cmnd[i]); 3000 3001 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |", 3002 ptr->resid, ptr->SCp.this_residual, ptr->SCp.buffers_residual); 3003 3004 if (ptr->SCp.phase & not_issued) 3005 SPRINTF("not issued|"); 3006 if (ptr->SCp.phase & selecting) 3007 SPRINTF("selecting|"); 3008 if (ptr->SCp.phase & disconnected) 3009 SPRINTF("disconnected|"); 3010 if (ptr->SCp.phase & aborted) 3011 SPRINTF("aborted|"); 3012 if (ptr->SCp.phase & identified) 3013 SPRINTF("identified|"); 3014 if (ptr->SCp.phase & completed) 3015 SPRINTF("completed|"); 3016 if (ptr->SCp.phase & spiordy) 3017 SPRINTF("spiordy|"); 3018 if (ptr->SCp.phase & syncneg) 3019 SPRINTF("syncneg|"); 3020 SPRINTF("; next=0x%p\n", SCNEXT(ptr)); 3021 3022 return (pos - start); 3023 } 3024 3025 static int get_ports(struct Scsi_Host *shpnt, char *pos) 3026 { 3027 char *start = pos; 3028 int s; 3029 3030 SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name); 3031 3032 s = GETPORT(SCSISEQ); 3033 SPRINTF("SCSISEQ( "); 3034 if (s & TEMODEO) 3035 SPRINTF("TARGET MODE "); 3036 if (s & ENSELO) 3037 SPRINTF("SELO "); 3038 if (s & ENSELI) 3039 SPRINTF("SELI "); 3040 if (s & ENRESELI) 3041 SPRINTF("RESELI "); 3042 if (s & ENAUTOATNO) 3043 SPRINTF("AUTOATNO "); 3044 if (s & ENAUTOATNI) 3045 SPRINTF("AUTOATNI "); 3046 if (s & ENAUTOATNP) 3047 SPRINTF("AUTOATNP "); 3048 if (s & SCSIRSTO) 3049 SPRINTF("SCSIRSTO "); 3050 SPRINTF(");"); 3051 3052 SPRINTF(" SCSISIG("); 3053 s = GETPORT(SCSISIG); 3054 switch (s & P_MASK) { 3055 case P_DATAO: 3056 SPRINTF("DATA OUT"); 3057 break; 3058 case P_DATAI: 3059 SPRINTF("DATA IN"); 3060 break; 3061 case P_CMD: 3062 SPRINTF("COMMAND"); 3063 break; 3064 case P_STATUS: 3065 SPRINTF("STATUS"); 3066 break; 3067 case P_MSGO: 3068 SPRINTF("MESSAGE OUT"); 3069 break; 3070 case P_MSGI: 3071 SPRINTF("MESSAGE IN"); 3072 break; 3073 default: 3074 SPRINTF("*invalid*"); 3075 break; 3076 } 3077 3078 SPRINTF("); "); 3079 3080 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo"); 3081 3082 SPRINTF("SSTAT( "); 3083 s = GETPORT(SSTAT0); 3084 if (s & TARGET) 3085 SPRINTF("TARGET "); 3086 if (s & SELDO) 3087 SPRINTF("SELDO "); 3088 if (s & SELDI) 3089 SPRINTF("SELDI "); 3090 if (s & SELINGO) 3091 SPRINTF("SELINGO "); 3092 if (s & SWRAP) 3093 SPRINTF("SWRAP "); 3094 if (s & SDONE) 3095 SPRINTF("SDONE "); 3096 if (s & SPIORDY) 3097 SPRINTF("SPIORDY "); 3098 if (s & DMADONE) 3099 SPRINTF("DMADONE "); 3100 3101 s = GETPORT(SSTAT1); 3102 if (s & SELTO) 3103 SPRINTF("SELTO "); 3104 if (s & ATNTARG) 3105 SPRINTF("ATNTARG "); 3106 if (s & SCSIRSTI) 3107 SPRINTF("SCSIRSTI "); 3108 if (s & PHASEMIS) 3109 SPRINTF("PHASEMIS "); 3110 if (s & BUSFREE) 3111 SPRINTF("BUSFREE "); 3112 if (s & SCSIPERR) 3113 SPRINTF("SCSIPERR "); 3114 if (s & PHASECHG) 3115 SPRINTF("PHASECHG "); 3116 if (s & REQINIT) 3117 SPRINTF("REQINIT "); 3118 SPRINTF("); "); 3119 3120 3121 SPRINTF("SSTAT( "); 3122 3123 s = GETPORT(SSTAT0) & GETPORT(SIMODE0); 3124 3125 if (s & TARGET) 3126 SPRINTF("TARGET "); 3127 if (s & SELDO) 3128 SPRINTF("SELDO "); 3129 if (s & SELDI) 3130 SPRINTF("SELDI "); 3131 if (s & SELINGO) 3132 SPRINTF("SELINGO "); 3133 if (s & SWRAP) 3134 SPRINTF("SWRAP "); 3135 if (s & SDONE) 3136 SPRINTF("SDONE "); 3137 if (s & SPIORDY) 3138 SPRINTF("SPIORDY "); 3139 if (s & DMADONE) 3140 SPRINTF("DMADONE "); 3141 3142 s = GETPORT(SSTAT1) & GETPORT(SIMODE1); 3143 3144 if (s & SELTO) 3145 SPRINTF("SELTO "); 3146 if (s & ATNTARG) 3147 SPRINTF("ATNTARG "); 3148 if (s & SCSIRSTI) 3149 SPRINTF("SCSIRSTI "); 3150 if (s & PHASEMIS) 3151 SPRINTF("PHASEMIS "); 3152 if (s & BUSFREE) 3153 SPRINTF("BUSFREE "); 3154 if (s & SCSIPERR) 3155 SPRINTF("SCSIPERR "); 3156 if (s & PHASECHG) 3157 SPRINTF("PHASECHG "); 3158 if (s & REQINIT) 3159 SPRINTF("REQINIT "); 3160 SPRINTF("); "); 3161 3162 SPRINTF("SXFRCTL0( "); 3163 3164 s = GETPORT(SXFRCTL0); 3165 if (s & SCSIEN) 3166 SPRINTF("SCSIEN "); 3167 if (s & DMAEN) 3168 SPRINTF("DMAEN "); 3169 if (s & CH1) 3170 SPRINTF("CH1 "); 3171 if (s & CLRSTCNT) 3172 SPRINTF("CLRSTCNT "); 3173 if (s & SPIOEN) 3174 SPRINTF("SPIOEN "); 3175 if (s & CLRCH1) 3176 SPRINTF("CLRCH1 "); 3177 SPRINTF("); "); 3178 3179 SPRINTF("SIGNAL( "); 3180 3181 s = GETPORT(SCSISIG); 3182 if (s & SIG_ATNI) 3183 SPRINTF("ATNI "); 3184 if (s & SIG_SELI) 3185 SPRINTF("SELI "); 3186 if (s & SIG_BSYI) 3187 SPRINTF("BSYI "); 3188 if (s & SIG_REQI) 3189 SPRINTF("REQI "); 3190 if (s & SIG_ACKI) 3191 SPRINTF("ACKI "); 3192 SPRINTF("); "); 3193 3194 SPRINTF("SELID(%02x), ", GETPORT(SELID)); 3195 3196 SPRINTF("STCNT(%d), ", GETSTCNT()); 3197 3198 SPRINTF("SSTAT2( "); 3199 3200 s = GETPORT(SSTAT2); 3201 if (s & SOFFSET) 3202 SPRINTF("SOFFSET "); 3203 if (s & SEMPTY) 3204 SPRINTF("SEMPTY "); 3205 if (s & SFULL) 3206 SPRINTF("SFULL "); 3207 SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT)); 3208 3209 s = GETPORT(SSTAT3); 3210 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f); 3211 3212 SPRINTF("SSTAT4( "); 3213 s = GETPORT(SSTAT4); 3214 if (s & SYNCERR) 3215 SPRINTF("SYNCERR "); 3216 if (s & FWERR) 3217 SPRINTF("FWERR "); 3218 if (s & FRERR) 3219 SPRINTF("FRERR "); 3220 SPRINTF("); "); 3221 3222 SPRINTF("DMACNTRL0( "); 3223 s = GETPORT(DMACNTRL0); 3224 SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT"); 3225 SPRINTF("%s ", s & DMA ? "DMA" : "PIO"); 3226 SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ"); 3227 if (s & ENDMA) 3228 SPRINTF("ENDMA "); 3229 if (s & INTEN) 3230 SPRINTF("INTEN "); 3231 if (s & RSTFIFO) 3232 SPRINTF("RSTFIFO "); 3233 if (s & SWINT) 3234 SPRINTF("SWINT "); 3235 SPRINTF("); "); 3236 3237 SPRINTF("DMASTAT( "); 3238 s = GETPORT(DMASTAT); 3239 if (s & ATDONE) 3240 SPRINTF("ATDONE "); 3241 if (s & WORDRDY) 3242 SPRINTF("WORDRDY "); 3243 if (s & DFIFOFULL) 3244 SPRINTF("DFIFOFULL "); 3245 if (s & DFIFOEMP) 3246 SPRINTF("DFIFOEMP "); 3247 SPRINTF(")\n"); 3248 3249 SPRINTF("enabled interrupts( "); 3250 3251 s = GETPORT(SIMODE0); 3252 if (s & ENSELDO) 3253 SPRINTF("ENSELDO "); 3254 if (s & ENSELDI) 3255 SPRINTF("ENSELDI "); 3256 if (s & ENSELINGO) 3257 SPRINTF("ENSELINGO "); 3258 if (s & ENSWRAP) 3259 SPRINTF("ENSWRAP "); 3260 if (s & ENSDONE) 3261 SPRINTF("ENSDONE "); 3262 if (s & ENSPIORDY) 3263 SPRINTF("ENSPIORDY "); 3264 if (s & ENDMADONE) 3265 SPRINTF("ENDMADONE "); 3266 3267 s = GETPORT(SIMODE1); 3268 if (s & ENSELTIMO) 3269 SPRINTF("ENSELTIMO "); 3270 if (s & ENATNTARG) 3271 SPRINTF("ENATNTARG "); 3272 if (s & ENPHASEMIS) 3273 SPRINTF("ENPHASEMIS "); 3274 if (s & ENBUSFREE) 3275 SPRINTF("ENBUSFREE "); 3276 if (s & ENSCSIPERR) 3277 SPRINTF("ENSCSIPERR "); 3278 if (s & ENPHASECHG) 3279 SPRINTF("ENPHASECHG "); 3280 if (s & ENREQINIT) 3281 SPRINTF("ENREQINIT "); 3282 SPRINTF(")\n"); 3283 3284 return (pos - start); 3285 } 3286 3287 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt) 3288 { 3289 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0) 3290 return -EINVAL; 3291 3292 #if defined(AHA152X_DEBUG) 3293 if(length>14 && strncmp("debug ", buffer+8, 6)==0) { 3294 int debug = HOSTDATA(shpnt)->debug; 3295 3296 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0); 3297 3298 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug); 3299 } else 3300 #endif 3301 #if defined(AHA152X_STAT) 3302 if(length>13 && strncmp("reset", buffer+8, 5)==0) { 3303 int i; 3304 3305 HOSTDATA(shpnt)->total_commands=0; 3306 HOSTDATA(shpnt)->disconnections=0; 3307 HOSTDATA(shpnt)->busfree_without_any_action=0; 3308 HOSTDATA(shpnt)->busfree_without_old_command=0; 3309 HOSTDATA(shpnt)->busfree_without_new_command=0; 3310 HOSTDATA(shpnt)->busfree_without_done_command=0; 3311 HOSTDATA(shpnt)->busfree_with_check_condition=0; 3312 for (i = idle; i<maxstate; i++) { 3313 HOSTDATA(shpnt)->count[i]=0; 3314 HOSTDATA(shpnt)->count_trans[i]=0; 3315 HOSTDATA(shpnt)->time[i]=0; 3316 } 3317 3318 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO); 3319 3320 } else 3321 #endif 3322 { 3323 return -EINVAL; 3324 } 3325 3326 3327 return length; 3328 } 3329 3330 #undef SPRINTF 3331 #define SPRINTF(args...) \ 3332 do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0) 3333 3334 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, 3335 off_t offset, int length, int inout) 3336 { 3337 int i; 3338 char *pos = buffer; 3339 Scsi_Cmnd *ptr; 3340 unsigned long flags; 3341 int thislength; 3342 3343 DPRINTK(debug_procinfo, 3344 KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n", 3345 buffer, offset, length, shpnt->host_no, inout); 3346 3347 3348 if (inout) 3349 return aha152x_set_info(buffer, length, shpnt); 3350 3351 SPRINTF(AHA152X_REVID "\n"); 3352 3353 SPRINTF("ioports 0x%04lx to 0x%04lx\n", 3354 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1); 3355 SPRINTF("interrupt 0x%02x\n", shpnt->irq); 3356 SPRINTF("disconnection/reconnection %s\n", 3357 RECONNECT ? "enabled" : "disabled"); 3358 SPRINTF("parity checking %s\n", 3359 PARITY ? "enabled" : "disabled"); 3360 SPRINTF("synchronous transfers %s\n", 3361 SYNCHRONOUS ? "enabled" : "disabled"); 3362 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands); 3363 3364 if(SYNCHRONOUS) { 3365 SPRINTF("synchronously operating targets (tick=50 ns):\n"); 3366 for (i = 0; i < 8; i++) 3367 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f) 3368 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n", 3369 i, 3370 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2), 3371 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50, 3372 HOSTDATA(shpnt)->syncrate[i] & 0x0f); 3373 } 3374 #if defined(AHA152X_DEBUG) 3375 #define PDEBUG(flags,txt) \ 3376 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt); 3377 3378 SPRINTF("enabled debugging options: "); 3379 3380 PDEBUG(debug_procinfo, "procinfo"); 3381 PDEBUG(debug_queue, "queue"); 3382 PDEBUG(debug_intr, "interrupt"); 3383 PDEBUG(debug_selection, "selection"); 3384 PDEBUG(debug_msgo, "message out"); 3385 PDEBUG(debug_msgi, "message in"); 3386 PDEBUG(debug_status, "status"); 3387 PDEBUG(debug_cmd, "command"); 3388 PDEBUG(debug_datai, "data in"); 3389 PDEBUG(debug_datao, "data out"); 3390 PDEBUG(debug_eh, "eh"); 3391 PDEBUG(debug_locks, "locks"); 3392 PDEBUG(debug_phases, "phases"); 3393 3394 SPRINTF("\n"); 3395 #endif 3396 3397 SPRINTF("\nqueue status:\n"); 3398 DO_LOCK(flags); 3399 if (ISSUE_SC) { 3400 SPRINTF("not yet issued commands:\n"); 3401 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr)) 3402 pos += get_command(pos, ptr); 3403 } else 3404 SPRINTF("no not yet issued commands\n"); 3405 DO_UNLOCK(flags); 3406 3407 if (CURRENT_SC) { 3408 SPRINTF("current command:\n"); 3409 pos += get_command(pos, CURRENT_SC); 3410 } else 3411 SPRINTF("no current command\n"); 3412 3413 if (DISCONNECTED_SC) { 3414 SPRINTF("disconnected commands:\n"); 3415 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr)) 3416 pos += get_command(pos, ptr); 3417 } else 3418 SPRINTF("no disconnected commands\n"); 3419 3420 pos += get_ports(shpnt, pos); 3421 3422 #if defined(AHA152X_STAT) 3423 SPRINTF("statistics:\n" 3424 "total commands: %d\n" 3425 "disconnections: %d\n" 3426 "busfree with check condition: %d\n" 3427 "busfree without old command: %d\n" 3428 "busfree without new command: %d\n" 3429 "busfree without done command: %d\n" 3430 "busfree without any action: %d\n" 3431 "state " 3432 "transitions " 3433 "count " 3434 "time\n", 3435 HOSTDATA(shpnt)->total_commands, 3436 HOSTDATA(shpnt)->disconnections, 3437 HOSTDATA(shpnt)->busfree_with_check_condition, 3438 HOSTDATA(shpnt)->busfree_without_old_command, 3439 HOSTDATA(shpnt)->busfree_without_new_command, 3440 HOSTDATA(shpnt)->busfree_without_done_command, 3441 HOSTDATA(shpnt)->busfree_without_any_action); 3442 for(i=0; i<maxstate; i++) { 3443 SPRINTF("%-10s %-12d %-12d %-12ld\n", 3444 states[i].name, 3445 HOSTDATA(shpnt)->count_trans[i], 3446 HOSTDATA(shpnt)->count[i], 3447 HOSTDATA(shpnt)->time[i]); 3448 } 3449 #endif 3450 3451 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos); 3452 3453 thislength = pos - (buffer + offset); 3454 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength); 3455 3456 if(thislength<0) { 3457 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n"); 3458 *start = NULL; 3459 return 0; 3460 } 3461 3462 thislength = thislength<length ? thislength : length; 3463 3464 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength); 3465 3466 *start = buffer + offset; 3467 return thislength < length ? thislength : length; 3468 } 3469 3470 static Scsi_Host_Template aha152x_driver_template = { 3471 .module = THIS_MODULE, 3472 .name = AHA152X_REVID, 3473 .proc_name = "aha152x", 3474 .proc_info = aha152x_proc_info, 3475 .queuecommand = aha152x_queue, 3476 .eh_abort_handler = aha152x_abort, 3477 .eh_device_reset_handler = aha152x_device_reset, 3478 .eh_bus_reset_handler = aha152x_bus_reset, 3479 .eh_host_reset_handler = aha152x_host_reset, 3480 .bios_param = aha152x_biosparam, 3481 .can_queue = 1, 3482 .this_id = 7, 3483 .sg_tablesize = SG_ALL, 3484 .cmd_per_lun = 1, 3485 .use_clustering = DISABLE_CLUSTERING, 3486 }; 3487 3488 #if !defined(PCMCIA) 3489 static int setup_count; 3490 static struct aha152x_setup setup[2]; 3491 3492 /* possible i/o addresses for the AIC-6260; default first */ 3493 static unsigned short ports[] = { 0x340, 0x140 }; 3494 3495 #if !defined(SKIP_BIOSTEST) 3496 /* possible locations for the Adaptec BIOS; defaults first */ 3497 static unsigned int addresses[] = 3498 { 3499 0xdc000, /* default first */ 3500 0xc8000, 3501 0xcc000, 3502 0xd0000, 3503 0xd4000, 3504 0xd8000, 3505 0xe0000, 3506 0xeb800, /* VTech Platinum SMP */ 3507 0xf0000, 3508 }; 3509 3510 /* signatures for various AIC-6[23]60 based controllers. 3511 The point in detecting signatures is to avoid useless and maybe 3512 harmful probes on ports. I'm not sure that all listed boards pass 3513 auto-configuration. For those which fail the BIOS signature is 3514 obsolete, because user intervention to supply the configuration is 3515 needed anyway. May be an information whether or not the BIOS supports 3516 extended translation could be also useful here. */ 3517 static struct signature { 3518 unsigned char *signature; 3519 int sig_offset; 3520 int sig_length; 3521 } signatures[] = 3522 { 3523 { "Adaptec AHA-1520 BIOS", 0x102e, 21 }, 3524 /* Adaptec 152x */ 3525 { "Adaptec AHA-1520B", 0x000b, 17 }, 3526 /* Adaptec 152x rev B */ 3527 { "Adaptec AHA-1520B", 0x0026, 17 }, 3528 /* Iomega Jaz Jet ISA (AIC6370Q) */ 3529 { "Adaptec ASW-B626 BIOS", 0x1029, 21 }, 3530 /* on-board controller */ 3531 { "Adaptec BIOS: ASW-B626", 0x000f, 22 }, 3532 /* on-board controller */ 3533 { "Adaptec ASW-B626 S2", 0x2e6c, 19 }, 3534 /* on-board controller */ 3535 { "Adaptec BIOS:AIC-6360", 0x000c, 21 }, 3536 /* on-board controller */ 3537 { "ScsiPro SP-360 BIOS", 0x2873, 19 }, 3538 /* ScsiPro-Controller */ 3539 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 }, 3540 /* Gigabyte Local-Bus-SCSI */ 3541 { "Adaptec BIOS:AVA-282X", 0x000c, 21 }, 3542 /* Adaptec 282x */ 3543 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 }, 3544 /* IBM Thinkpad Dock II */ 3545 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 }, 3546 /* IBM Thinkpad Dock II SCSI */ 3547 { "DTC3520A Host Adapter BIOS", 0x318a, 26 }, 3548 /* DTC 3520A ISA SCSI */ 3549 }; 3550 #endif /* !SKIP_BIOSTEST */ 3551 3552 /* 3553 * Test, if port_base is valid. 3554 * 3555 */ 3556 static int aha152x_porttest(int io_port) 3557 { 3558 int i; 3559 3560 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */ 3561 for (i = 0; i < 16; i++) 3562 SETPORT(io_port + O_STACK, i); 3563 3564 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */ 3565 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++) 3566 ; 3567 3568 return (i == 16); 3569 } 3570 3571 static int tc1550_porttest(int io_port) 3572 { 3573 int i; 3574 3575 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */ 3576 for (i = 0; i < 16; i++) 3577 SETPORT(io_port + O_STACK, i); 3578 3579 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */ 3580 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++) 3581 ; 3582 3583 return (i == 16); 3584 } 3585 3586 3587 static int checksetup(struct aha152x_setup *setup) 3588 { 3589 int i; 3590 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++) 3591 ; 3592 3593 if (i == ARRAY_SIZE(ports)) 3594 return 0; 3595 3596 if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) { 3597 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port); 3598 return 0; 3599 } 3600 3601 if( aha152x_porttest(setup->io_port) ) { 3602 setup->tc1550=0; 3603 } else if( tc1550_porttest(setup->io_port) ) { 3604 setup->tc1550=1; 3605 } else { 3606 release_region(setup->io_port, IO_RANGE); 3607 return 0; 3608 } 3609 3610 release_region(setup->io_port, IO_RANGE); 3611 3612 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX)) 3613 return 0; 3614 3615 if ((setup->scsiid < 0) || (setup->scsiid > 7)) 3616 return 0; 3617 3618 if ((setup->reconnect < 0) || (setup->reconnect > 1)) 3619 return 0; 3620 3621 if ((setup->parity < 0) || (setup->parity > 1)) 3622 return 0; 3623 3624 if ((setup->synchronous < 0) || (setup->synchronous > 1)) 3625 return 0; 3626 3627 if ((setup->ext_trans < 0) || (setup->ext_trans > 1)) 3628 return 0; 3629 3630 3631 return 1; 3632 } 3633 3634 3635 static int __init aha152x_init(void) 3636 { 3637 int i, j, ok; 3638 #if defined(AUTOCONF) 3639 aha152x_config conf; 3640 #endif 3641 #ifdef __ISAPNP__ 3642 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL}; 3643 #endif 3644 3645 if ( setup_count ) { 3646 printk(KERN_INFO "aha152x: processing commandline: "); 3647 3648 for (i = 0; i<setup_count; i++) { 3649 if (!checksetup(&setup[i])) { 3650 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf); 3651 printk(KERN_ERR "aha152x: invalid line\n"); 3652 } 3653 } 3654 printk("ok\n"); 3655 } 3656 3657 #if defined(SETUP0) 3658 if (setup_count < ARRAY_SIZE(setup)) { 3659 struct aha152x_setup override = SETUP0; 3660 3661 if (setup_count == 0 || (override.io_port != setup[0].io_port)) { 3662 if (!checksetup(&override)) { 3663 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n", 3664 override.io_port, 3665 override.irq, 3666 override.scsiid, 3667 override.reconnect, 3668 override.parity, 3669 override.synchronous, 3670 override.delay, 3671 override.ext_trans); 3672 } else 3673 setup[setup_count++] = override; 3674 } 3675 } 3676 #endif 3677 3678 #if defined(SETUP1) 3679 if (setup_count < ARRAY_SIZE(setup)) { 3680 struct aha152x_setup override = SETUP1; 3681 3682 if (setup_count == 0 || (override.io_port != setup[0].io_port)) { 3683 if (!checksetup(&override)) { 3684 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n", 3685 override.io_port, 3686 override.irq, 3687 override.scsiid, 3688 override.reconnect, 3689 override.parity, 3690 override.synchronous, 3691 override.delay, 3692 override.ext_trans); 3693 } else 3694 setup[setup_count++] = override; 3695 } 3696 } 3697 #endif 3698 3699 #if defined(MODULE) 3700 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) { 3701 if(aha152x[0]!=0) { 3702 setup[setup_count].conf = ""; 3703 setup[setup_count].io_port = aha152x[0]; 3704 setup[setup_count].irq = aha152x[1]; 3705 setup[setup_count].scsiid = aha152x[2]; 3706 setup[setup_count].reconnect = aha152x[3]; 3707 setup[setup_count].parity = aha152x[4]; 3708 setup[setup_count].synchronous = aha152x[5]; 3709 setup[setup_count].delay = aha152x[6]; 3710 setup[setup_count].ext_trans = aha152x[7]; 3711 #if defined(AHA152X_DEBUG) 3712 setup[setup_count].debug = aha152x[8]; 3713 #endif 3714 } else if(io[0]!=0 || irq[0]!=0) { 3715 if(io[0]!=0) setup[setup_count].io_port = io[0]; 3716 if(irq[0]!=0) setup[setup_count].irq = irq[0]; 3717 3718 setup[setup_count].scsiid = scsiid[0]; 3719 setup[setup_count].reconnect = reconnect[0]; 3720 setup[setup_count].parity = parity[0]; 3721 setup[setup_count].synchronous = sync[0]; 3722 setup[setup_count].delay = delay[0]; 3723 setup[setup_count].ext_trans = exttrans[0]; 3724 #if defined(AHA152X_DEBUG) 3725 setup[setup_count].debug = debug[0]; 3726 #endif 3727 } 3728 3729 if (checksetup(&setup[setup_count])) 3730 setup_count++; 3731 else 3732 printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n", 3733 setup[setup_count].io_port, 3734 setup[setup_count].irq, 3735 setup[setup_count].scsiid, 3736 setup[setup_count].reconnect, 3737 setup[setup_count].parity, 3738 setup[setup_count].synchronous, 3739 setup[setup_count].delay, 3740 setup[setup_count].ext_trans); 3741 } 3742 3743 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) { 3744 if(aha152x1[0]!=0) { 3745 setup[setup_count].conf = ""; 3746 setup[setup_count].io_port = aha152x1[0]; 3747 setup[setup_count].irq = aha152x1[1]; 3748 setup[setup_count].scsiid = aha152x1[2]; 3749 setup[setup_count].reconnect = aha152x1[3]; 3750 setup[setup_count].parity = aha152x1[4]; 3751 setup[setup_count].synchronous = aha152x1[5]; 3752 setup[setup_count].delay = aha152x1[6]; 3753 setup[setup_count].ext_trans = aha152x1[7]; 3754 #if defined(AHA152X_DEBUG) 3755 setup[setup_count].debug = aha152x1[8]; 3756 #endif 3757 } else if(io[1]!=0 || irq[1]!=0) { 3758 if(io[1]!=0) setup[setup_count].io_port = io[1]; 3759 if(irq[1]!=0) setup[setup_count].irq = irq[1]; 3760 3761 setup[setup_count].scsiid = scsiid[1]; 3762 setup[setup_count].reconnect = reconnect[1]; 3763 setup[setup_count].parity = parity[1]; 3764 setup[setup_count].synchronous = sync[1]; 3765 setup[setup_count].delay = delay[1]; 3766 setup[setup_count].ext_trans = exttrans[1]; 3767 #if defined(AHA152X_DEBUG) 3768 setup[setup_count].debug = debug[1]; 3769 #endif 3770 } 3771 if (checksetup(&setup[setup_count])) 3772 setup_count++; 3773 else 3774 printk(KERN_ERR "aha152x: invalid module params io=0x%x, irq=%d,scsiid=%d,reconnect=%d,parity=%d,sync=%d,delay=%d,exttrans=%d\n", 3775 setup[setup_count].io_port, 3776 setup[setup_count].irq, 3777 setup[setup_count].scsiid, 3778 setup[setup_count].reconnect, 3779 setup[setup_count].parity, 3780 setup[setup_count].synchronous, 3781 setup[setup_count].delay, 3782 setup[setup_count].ext_trans); 3783 } 3784 #endif 3785 3786 #ifdef __ISAPNP__ 3787 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) { 3788 while ( setup_count<ARRAY_SIZE(setup) && 3789 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) { 3790 if (pnp_device_attach(dev) < 0) 3791 continue; 3792 3793 if (pnp_activate_dev(dev) < 0) { 3794 pnp_device_detach(dev); 3795 continue; 3796 } 3797 3798 if (!pnp_port_valid(dev, 0)) { 3799 pnp_device_detach(dev); 3800 continue; 3801 } 3802 3803 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) { 3804 pnp_device_detach(dev); 3805 continue; 3806 } 3807 3808 setup[setup_count].io_port = pnp_port_start(dev, 0); 3809 setup[setup_count].irq = pnp_irq(dev, 0); 3810 setup[setup_count].scsiid = 7; 3811 setup[setup_count].reconnect = 1; 3812 setup[setup_count].parity = 1; 3813 setup[setup_count].synchronous = 1; 3814 setup[setup_count].delay = DELAY_DEFAULT; 3815 setup[setup_count].ext_trans = 0; 3816 #if defined(AHA152X_DEBUG) 3817 setup[setup_count].debug = DEBUG_DEFAULT; 3818 #endif 3819 #if defined(__ISAPNP__) 3820 pnpdev[setup_count] = dev; 3821 #endif 3822 printk (KERN_INFO 3823 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n", 3824 setup[setup_count].io_port, setup[setup_count].irq); 3825 setup_count++; 3826 } 3827 } 3828 #endif 3829 3830 #if defined(AUTOCONF) 3831 if (setup_count<ARRAY_SIZE(setup)) { 3832 #if !defined(SKIP_BIOSTEST) 3833 ok = 0; 3834 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) { 3835 void __iomem *p = ioremap(addresses[i], 0x4000); 3836 if (!p) 3837 continue; 3838 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++) 3839 ok = check_signature(p + signatures[j].sig_offset, 3840 signatures[j].signature, signatures[j].sig_length); 3841 iounmap(p); 3842 } 3843 if (!ok && setup_count == 0) 3844 return 0; 3845 3846 printk(KERN_INFO "aha152x: BIOS test: passed, "); 3847 #else 3848 printk(KERN_INFO "aha152x: "); 3849 #endif /* !SKIP_BIOSTEST */ 3850 3851 ok = 0; 3852 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) { 3853 if ((setup_count == 1) && (setup[0].io_port == ports[i])) 3854 continue; 3855 3856 if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) { 3857 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]); 3858 continue; 3859 } 3860 3861 if (aha152x_porttest(ports[i])) { 3862 setup[setup_count].tc1550 = 0; 3863 3864 conf.cf_port = 3865 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB); 3866 } else if (tc1550_porttest(ports[i])) { 3867 setup[setup_count].tc1550 = 1; 3868 3869 conf.cf_port = 3870 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB); 3871 } else { 3872 release_region(ports[i], IO_RANGE); 3873 continue; 3874 } 3875 3876 release_region(ports[i], IO_RANGE); 3877 3878 ok++; 3879 setup[setup_count].io_port = ports[i]; 3880 setup[setup_count].irq = IRQ_MIN + conf.cf_irq; 3881 setup[setup_count].scsiid = conf.cf_id; 3882 setup[setup_count].reconnect = conf.cf_tardisc; 3883 setup[setup_count].parity = !conf.cf_parity; 3884 setup[setup_count].synchronous = conf.cf_syncneg; 3885 setup[setup_count].delay = DELAY_DEFAULT; 3886 setup[setup_count].ext_trans = 0; 3887 #if defined(AHA152X_DEBUG) 3888 setup[setup_count].debug = DEBUG_DEFAULT; 3889 #endif 3890 setup_count++; 3891 3892 } 3893 3894 if (ok) 3895 printk("auto configuration: ok, "); 3896 } 3897 #endif 3898 3899 printk("%d controller(s) configured\n", setup_count); 3900 3901 for (i=0; i<setup_count; i++) { 3902 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) { 3903 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]); 3904 3905 if( !shpnt ) { 3906 release_region(setup[i].io_port, IO_RANGE); 3907 #if defined(__ISAPNP__) 3908 } else if( pnpdev[i] ) { 3909 HOSTDATA(shpnt)->pnpdev=pnpdev[i]; 3910 pnpdev[i]=NULL; 3911 #endif 3912 } 3913 } else { 3914 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port); 3915 } 3916 3917 #if defined(__ISAPNP__) 3918 if( pnpdev[i] ) 3919 pnp_device_detach(pnpdev[i]); 3920 #endif 3921 } 3922 3923 return registered_count>0; 3924 } 3925 3926 static void __exit aha152x_exit(void) 3927 { 3928 int i; 3929 3930 for(i=0; i<ARRAY_SIZE(setup); i++) { 3931 aha152x_release(aha152x_host[i]); 3932 aha152x_host[i]=NULL; 3933 } 3934 } 3935 3936 module_init(aha152x_init); 3937 module_exit(aha152x_exit); 3938 3939 #if !defined(MODULE) 3940 static int __init aha152x_setup(char *str) 3941 { 3942 #if defined(AHA152X_DEBUG) 3943 int ints[11]; 3944 #else 3945 int ints[10]; 3946 #endif 3947 get_options(str, ARRAY_SIZE(ints), ints); 3948 3949 if(setup_count>=ARRAY_SIZE(setup)) { 3950 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n"); 3951 return 1; 3952 } 3953 3954 setup[setup_count].conf = str; 3955 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340; 3956 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11; 3957 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7; 3958 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1; 3959 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1; 3960 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1; 3961 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT; 3962 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0; 3963 #if defined(AHA152X_DEBUG) 3964 setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT; 3965 if (ints[0] > 9) { 3966 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>" 3967 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n"); 3968 #else 3969 if (ints[0] > 8) { /*}*/ 3970 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>" 3971 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n"); 3972 #endif 3973 } else { 3974 setup_count++; 3975 return 0; 3976 } 3977 3978 return 1; 3979 } 3980 __setup("aha152x=", aha152x_setup); 3981 #endif 3982 3983 #endif /* !PCMCIA */ 3984