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 return ret; 1229 } 1230 1231 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs) 1232 { 1233 Scsi_Cmnd *ptr; 1234 1235 ptr=*SCs; 1236 while(ptr) { 1237 Scsi_Cmnd *next; 1238 1239 if(SCDATA(ptr)) { 1240 next = SCNEXT(ptr); 1241 } else { 1242 printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr); 1243 next = NULL; 1244 } 1245 1246 if (!ptr->device->soft_reset) { 1247 DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr); 1248 remove_SC(SCs, ptr); 1249 HOSTDATA(shpnt)->commands--; 1250 kfree(ptr->host_scribble); 1251 ptr->host_scribble=NULL; 1252 } 1253 1254 ptr = next; 1255 } 1256 } 1257 1258 /* 1259 * Reset the bus 1260 * 1261 */ 1262 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt) 1263 { 1264 struct Scsi_Host *shpnt = SCpnt->device->host; 1265 unsigned long flags; 1266 1267 DO_LOCK(flags); 1268 1269 #if defined(AHA152X_DEBUG) 1270 if(HOSTDATA(shpnt)->debug & debug_eh) { 1271 printk(DEBUG_LEAD "aha152x_bus_reset(%p)", CMDINFO(SCpnt), SCpnt); 1272 show_queues(shpnt); 1273 } 1274 #endif 1275 1276 free_hard_reset_SCs(shpnt, &ISSUE_SC); 1277 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC); 1278 1279 DPRINTK(debug_eh, DEBUG_LEAD "resetting bus\n", CMDINFO(SCpnt)); 1280 1281 SETPORT(SCSISEQ, SCSIRSTO); 1282 mdelay(256); 1283 SETPORT(SCSISEQ, 0); 1284 mdelay(DELAY); 1285 1286 DPRINTK(debug_eh, DEBUG_LEAD "bus resetted\n", CMDINFO(SCpnt)); 1287 1288 setup_expected_interrupts(shpnt); 1289 if(HOSTDATA(shpnt)->commands==0) 1290 SETPORT(PORTA, 0); 1291 1292 DO_UNLOCK(flags); 1293 1294 return SUCCESS; 1295 } 1296 1297 1298 /* 1299 * Restore default values to the AIC-6260 registers and reset the fifos 1300 * 1301 */ 1302 static void reset_ports(struct Scsi_Host *shpnt) 1303 { 1304 unsigned long flags; 1305 1306 /* disable interrupts */ 1307 SETPORT(DMACNTRL0, RSTFIFO); 1308 1309 SETPORT(SCSISEQ, 0); 1310 1311 SETPORT(SXFRCTL1, 0); 1312 SETPORT(SCSISIG, 0); 1313 SETRATE(0); 1314 1315 /* clear all interrupt conditions */ 1316 SETPORT(SSTAT0, 0x7f); 1317 SETPORT(SSTAT1, 0xef); 1318 1319 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR); 1320 1321 SETPORT(DMACNTRL0, 0); 1322 SETPORT(DMACNTRL1, 0); 1323 1324 SETPORT(BRSTCNTRL, 0xf1); 1325 1326 /* clear SCSI fifos and transfer count */ 1327 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 1328 SETPORT(SXFRCTL0, CH1); 1329 1330 DO_LOCK(flags); 1331 setup_expected_interrupts(shpnt); 1332 DO_UNLOCK(flags); 1333 } 1334 1335 /* 1336 * Reset the host (bus and controller) 1337 * 1338 */ 1339 int aha152x_host_reset(Scsi_Cmnd * SCpnt) 1340 { 1341 #if defined(AHA152X_DEBUG) 1342 struct Scsi_Host *shpnt = SCpnt->device->host; 1343 #endif 1344 1345 DPRINTK(debug_eh, DEBUG_LEAD "aha152x_host_reset(%p)\n", CMDINFO(SCpnt), SCpnt); 1346 1347 aha152x_bus_reset(SCpnt); 1348 1349 DPRINTK(debug_eh, DEBUG_LEAD "resetting ports\n", CMDINFO(SCpnt)); 1350 reset_ports(SCpnt->device->host); 1351 1352 return SUCCESS; 1353 } 1354 1355 /* 1356 * Return the "logical geometry" 1357 * 1358 */ 1359 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev, 1360 sector_t capacity, int *info_array) 1361 { 1362 struct Scsi_Host *shpnt = sdev->host; 1363 1364 /* try default translation */ 1365 info_array[0] = 64; 1366 info_array[1] = 32; 1367 info_array[2] = (unsigned long)capacity / (64 * 32); 1368 1369 /* for disks >1GB do some guessing */ 1370 if (info_array[2] >= 1024) { 1371 int info[3]; 1372 1373 /* try to figure out the geometry from the partition table */ 1374 if (scsicam_bios_param(bdev, capacity, info) < 0 || 1375 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) { 1376 if (EXT_TRANS) { 1377 printk(KERN_NOTICE 1378 "aha152x: unable to verify geometry for disk with >1GB.\n" 1379 " using extended translation.\n"); 1380 info_array[0] = 255; 1381 info_array[1] = 63; 1382 info_array[2] = (unsigned long)capacity / (255 * 63); 1383 } else { 1384 printk(KERN_NOTICE 1385 "aha152x: unable to verify geometry for disk with >1GB.\n" 1386 " Using default translation. Please verify yourself.\n" 1387 " Perhaps you need to enable extended translation in the driver.\n" 1388 " See Documentation/scsi/aha152x.txt for details.\n"); 1389 } 1390 } else { 1391 info_array[0] = info[0]; 1392 info_array[1] = info[1]; 1393 info_array[2] = info[2]; 1394 1395 if (info[0] == 255 && !EXT_TRANS) { 1396 printk(KERN_NOTICE 1397 "aha152x: current partition table is using extended translation.\n" 1398 " using it also, although it's not explicitly enabled.\n"); 1399 } 1400 } 1401 } 1402 1403 return 0; 1404 } 1405 1406 /* 1407 * Internal done function 1408 * 1409 */ 1410 static void done(struct Scsi_Host *shpnt, int error) 1411 { 1412 if (CURRENT_SC) { 1413 if(DONE_SC) 1414 printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC); 1415 1416 DONE_SC = CURRENT_SC; 1417 CURRENT_SC = NULL; 1418 DONE_SC->result = error; 1419 } else 1420 printk(KERN_ERR "aha152x: done() called outside of command\n"); 1421 } 1422 1423 static struct work_struct aha152x_tq; 1424 1425 /* 1426 * Run service completions on the card with interrupts enabled. 1427 * 1428 */ 1429 static void run(void) 1430 { 1431 int i; 1432 for (i = 0; i<ARRAY_SIZE(aha152x_host); i++) { 1433 struct Scsi_Host *shpnt = aha152x_host[i]; 1434 if (shpnt && HOSTDATA(shpnt)->service) { 1435 HOSTDATA(shpnt)->service=0; 1436 is_complete(shpnt); 1437 } 1438 } 1439 } 1440 1441 /* 1442 * Interrupts handler 1443 * 1444 */ 1445 1446 static irqreturn_t intr(int irqno, void *dev_id, struct pt_regs *regs) 1447 { 1448 struct Scsi_Host *shpnt = lookup_irq(irqno); 1449 unsigned char rev, dmacntrl0; 1450 1451 if (!shpnt) { 1452 printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno); 1453 return IRQ_NONE; 1454 } 1455 1456 /* 1457 * Read a couple of registers that are known to not be all 1's. If 1458 * we read all 1's (-1), that means that either: 1459 * 1460 * a. The host adapter chip has gone bad, and we cannot control it, 1461 * OR 1462 * b. The host adapter is a PCMCIA card that has been ejected 1463 * 1464 * In either case, we cannot do anything with the host adapter at 1465 * this point in time. So just ignore the interrupt and return. 1466 * In the latter case, the interrupt might actually be meant for 1467 * someone else sharing this IRQ, and that driver will handle it. 1468 */ 1469 rev = GETPORT(REV); 1470 dmacntrl0 = GETPORT(DMACNTRL0); 1471 if ((rev == 0xFF) && (dmacntrl0 == 0xFF)) 1472 return IRQ_NONE; 1473 1474 /* no more interrupts from the controller, while we're busy. 1475 INTEN is restored by the BH handler */ 1476 CLRBITS(DMACNTRL0, INTEN); 1477 1478 #if 0 1479 /* check if there is already something to be 1480 serviced; should not happen */ 1481 if(HOSTDATA(shpnt)->service) { 1482 printk(KERN_ERR "aha152x%d: lost interrupt (%d)\n", HOSTNO, HOSTDATA(shpnt)->service); 1483 show_queues(shpnt); 1484 } 1485 #endif 1486 1487 /* Poke the BH handler */ 1488 HOSTDATA(shpnt)->service++; 1489 INIT_WORK(&aha152x_tq, (void *) run, NULL); 1490 schedule_work(&aha152x_tq); 1491 return IRQ_HANDLED; 1492 } 1493 1494 /* 1495 * busfree phase 1496 * - handle completition/disconnection/error of current command 1497 * - start selection for next command (if any) 1498 */ 1499 static void busfree_run(struct Scsi_Host *shpnt) 1500 { 1501 unsigned long flags; 1502 #if defined(AHA152X_STAT) 1503 int action=0; 1504 #endif 1505 1506 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 1507 SETPORT(SXFRCTL0, CH1); 1508 1509 SETPORT(SSTAT1, CLRBUSFREE); 1510 1511 if(CURRENT_SC) { 1512 #if defined(AHA152X_STAT) 1513 action++; 1514 #endif 1515 CURRENT_SC->SCp.phase &= ~syncneg; 1516 1517 if(CURRENT_SC->SCp.phase & completed) { 1518 /* target sent COMMAND COMPLETE */ 1519 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16)); 1520 1521 } else if(CURRENT_SC->SCp.phase & aborted) { 1522 DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC)); 1523 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16)); 1524 1525 } else if(CURRENT_SC->SCp.phase & resetted) { 1526 DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC)); 1527 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16)); 1528 1529 } else if(CURRENT_SC->SCp.phase & disconnected) { 1530 /* target sent DISCONNECT */ 1531 DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n", 1532 CMDINFO(CURRENT_SC), 1533 CURRENT_SC->resid, 1534 CURRENT_SC->request_bufflen); 1535 #if defined(AHA152X_STAT) 1536 HOSTDATA(shpnt)->disconnections++; 1537 #endif 1538 append_SC(&DISCONNECTED_SC, CURRENT_SC); 1539 CURRENT_SC->SCp.phase |= 1 << 16; 1540 CURRENT_SC = NULL; 1541 1542 } else { 1543 done(shpnt, DID_ERROR << 16); 1544 } 1545 #if defined(AHA152X_STAT) 1546 } else { 1547 HOSTDATA(shpnt)->busfree_without_old_command++; 1548 #endif 1549 } 1550 1551 DO_LOCK(flags); 1552 1553 if(DONE_SC) { 1554 #if defined(AHA152X_STAT) 1555 action++; 1556 #endif 1557 1558 if(DONE_SC->SCp.phase & check_condition) { 1559 #if 0 1560 if(HOSTDATA(shpnt)->debug & debug_eh) { 1561 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC)); 1562 scsi_print_sense("bh", DONE_SC); 1563 } 1564 #endif 1565 1566 /* restore old command */ 1567 memcpy((void *) DONE_SC->cmnd, (void *) DONE_SC->data_cmnd, sizeof(DONE_SC->data_cmnd)); 1568 DONE_SC->request_buffer = DONE_SC->buffer; 1569 DONE_SC->request_bufflen = DONE_SC->bufflen; 1570 DONE_SC->use_sg = DONE_SC->old_use_sg; 1571 DONE_SC->cmd_len = DONE_SC->old_cmd_len; 1572 1573 DONE_SC->SCp.Status = 0x02; 1574 1575 HOSTDATA(shpnt)->commands--; 1576 if (!HOSTDATA(shpnt)->commands) 1577 SETPORT(PORTA, 0); /* turn led off */ 1578 } else if(DONE_SC->SCp.Status==0x02) { 1579 #if defined(AHA152X_STAT) 1580 HOSTDATA(shpnt)->busfree_with_check_condition++; 1581 #endif 1582 #if 0 1583 DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC)); 1584 #endif 1585 1586 if(!(DONE_SC->SCp.Status & not_issued)) { 1587 Scsi_Cmnd *ptr = DONE_SC; 1588 DONE_SC=NULL; 1589 #if 0 1590 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr)); 1591 #endif 1592 1593 ptr->cmnd[0] = REQUEST_SENSE; 1594 ptr->cmnd[1] = 0; 1595 ptr->cmnd[2] = 0; 1596 ptr->cmnd[3] = 0; 1597 ptr->cmnd[4] = sizeof(ptr->sense_buffer); 1598 ptr->cmnd[5] = 0; 1599 ptr->cmd_len = 6; 1600 ptr->use_sg = 0; 1601 ptr->request_buffer = ptr->sense_buffer; 1602 ptr->request_bufflen = sizeof(ptr->sense_buffer); 1603 1604 DO_UNLOCK(flags); 1605 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done); 1606 DO_LOCK(flags); 1607 #if 0 1608 } else { 1609 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC)); 1610 #endif 1611 } 1612 } 1613 1614 if(DONE_SC && DONE_SC->scsi_done) { 1615 #if defined(AHA152X_DEBUG) 1616 int hostno=DONE_SC->device->host->host_no; 1617 int id=DONE_SC->device->id & 0xf; 1618 int lun=DONE_SC->device->lun & 0x7; 1619 #endif 1620 Scsi_Cmnd *ptr = DONE_SC; 1621 DONE_SC=NULL; 1622 1623 /* turn led off, when no commands are in the driver */ 1624 HOSTDATA(shpnt)->commands--; 1625 if (!HOSTDATA(shpnt)->commands) 1626 SETPORT(PORTA, 0); /* turn led off */ 1627 1628 if(ptr->scsi_done != reset_done) { 1629 kfree(ptr->host_scribble); 1630 ptr->host_scribble=NULL; 1631 } 1632 1633 DO_UNLOCK(flags); 1634 DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr); 1635 ptr->scsi_done(ptr); 1636 DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr); 1637 DO_LOCK(flags); 1638 } 1639 1640 DONE_SC=NULL; 1641 #if defined(AHA152X_STAT) 1642 } else { 1643 HOSTDATA(shpnt)->busfree_without_done_command++; 1644 #endif 1645 } 1646 1647 if(ISSUE_SC) 1648 CURRENT_SC = remove_first_SC(&ISSUE_SC); 1649 1650 DO_UNLOCK(flags); 1651 1652 if(CURRENT_SC) { 1653 #if defined(AHA152X_STAT) 1654 action++; 1655 #endif 1656 CURRENT_SC->SCp.phase |= selecting; 1657 1658 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC)); 1659 1660 /* clear selection timeout */ 1661 SETPORT(SSTAT1, SELTO); 1662 1663 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id); 1664 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER); 1665 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0)); 1666 } else { 1667 #if defined(AHA152X_STAT) 1668 HOSTDATA(shpnt)->busfree_without_new_command++; 1669 #endif 1670 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0); 1671 } 1672 1673 #if defined(AHA152X_STAT) 1674 if(!action) 1675 HOSTDATA(shpnt)->busfree_without_any_action++; 1676 #endif 1677 } 1678 1679 /* 1680 * Selection done (OUT) 1681 * - queue IDENTIFY message and SDTR to selected target for message out 1682 * (ATN asserted automagically via ENAUTOATNO in busfree()) 1683 */ 1684 static void seldo_run(struct Scsi_Host *shpnt) 1685 { 1686 SETPORT(SCSISIG, 0); 1687 SETPORT(SSTAT1, CLRBUSFREE); 1688 SETPORT(SSTAT1, CLRPHASECHG); 1689 1690 CURRENT_SC->SCp.phase &= ~(selecting|not_issued); 1691 1692 SETPORT(SCSISEQ, 0); 1693 1694 if (TESTLO(SSTAT0, SELDO)) { 1695 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC)); 1696 done(shpnt, DID_NO_CONNECT << 16); 1697 return; 1698 } 1699 1700 SETPORT(SSTAT0, CLRSELDO); 1701 1702 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun)); 1703 1704 if (CURRENT_SC->SCp.phase & aborting) { 1705 ADDMSGO(ABORT); 1706 } else if (CURRENT_SC->SCp.phase & resetting) { 1707 ADDMSGO(BUS_DEVICE_RESET); 1708 } else if (SYNCNEG==0 && SYNCHRONOUS) { 1709 CURRENT_SC->SCp.phase |= syncneg; 1710 ADDMSGO(EXTENDED_MESSAGE); 1711 ADDMSGO(3); 1712 ADDMSGO(EXTENDED_SDTR); 1713 ADDMSGO(50); /* 200ns */ 1714 ADDMSGO(8); /* 8 byte req/ack offset */ 1715 1716 SYNCNEG=1; /* negotiation in progress */ 1717 } 1718 1719 SETRATE(SYNCRATE); 1720 } 1721 1722 /* 1723 * Selection timeout 1724 * - return command to mid-level with failure cause 1725 * 1726 */ 1727 static void selto_run(struct Scsi_Host *shpnt) 1728 { 1729 SETPORT(SCSISEQ, 0); 1730 SETPORT(SSTAT1, CLRSELTIMO); 1731 1732 DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC)); 1733 1734 if(!CURRENT_SC) { 1735 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC)); 1736 return; 1737 } 1738 1739 CURRENT_SC->SCp.phase &= ~selecting; 1740 1741 if (CURRENT_SC->SCp.phase & aborted) { 1742 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC)); 1743 done(shpnt, DID_ABORT << 16); 1744 } else if (TESTLO(SSTAT0, SELINGO)) { 1745 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC)); 1746 done(shpnt, DID_BUS_BUSY << 16); 1747 } else { 1748 /* ARBITRATION won, but SELECTION failed */ 1749 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC)); 1750 done(shpnt, DID_NO_CONNECT << 16); 1751 } 1752 } 1753 1754 /* 1755 * Selection in done 1756 * - put current command back to issue queue 1757 * (reconnection of a disconnected nexus instead 1758 * of successful selection out) 1759 * 1760 */ 1761 static void seldi_run(struct Scsi_Host *shpnt) 1762 { 1763 int selid; 1764 int target; 1765 unsigned long flags; 1766 1767 SETPORT(SCSISIG, 0); 1768 SETPORT(SSTAT0, CLRSELDI); 1769 SETPORT(SSTAT1, CLRBUSFREE); 1770 SETPORT(SSTAT1, CLRPHASECHG); 1771 1772 if(CURRENT_SC) { 1773 if(!(CURRENT_SC->SCp.phase & not_issued)) 1774 printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC)); 1775 1776 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC)); 1777 1778 DO_LOCK(flags); 1779 append_SC(&ISSUE_SC, CURRENT_SC); 1780 DO_UNLOCK(flags); 1781 1782 CURRENT_SC = NULL; 1783 } 1784 1785 if(!DISCONNECTED_SC) { 1786 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC)); 1787 return; 1788 } 1789 1790 RECONN_TARGET=-1; 1791 1792 selid = GETPORT(SELID) & ~(1 << shpnt->this_id); 1793 1794 if (selid==0) { 1795 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid); 1796 return; 1797 } 1798 1799 for(target=7; !(selid & (1 << target)); target--) 1800 ; 1801 1802 if(selid & ~(1 << target)) { 1803 printk("aha152x%d: multiple targets reconnected (%02x)\n", 1804 HOSTNO, selid); 1805 } 1806 1807 1808 SETPORT(SCSIID, (shpnt->this_id << OID_) | target); 1809 SETPORT(SCSISEQ, 0); 1810 1811 SETRATE(HOSTDATA(shpnt)->syncrate[target]); 1812 1813 RECONN_TARGET=target; 1814 DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid); 1815 } 1816 1817 /* 1818 * message in phase 1819 * - handle initial message after reconnection to identify 1820 * reconnecting nexus 1821 * - queue command on DISCONNECTED_SC on DISCONNECT message 1822 * - set completed flag on COMMAND COMPLETE 1823 * (other completition code moved to busfree_run) 1824 * - handle response to SDTR 1825 * - clear synchronous transfer agreements on BUS RESET 1826 * 1827 * FIXME: what about SAVE POINTERS, RESTORE POINTERS? 1828 * 1829 */ 1830 static void msgi_run(struct Scsi_Host *shpnt) 1831 { 1832 for(;;) { 1833 int sstat1 = GETPORT(SSTAT1); 1834 1835 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT)) 1836 return; 1837 1838 if(TESTLO(SSTAT0,SPIORDY)) { 1839 DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC)); 1840 return; 1841 } 1842 1843 ADDMSGI(GETPORT(SCSIDAT)); 1844 1845 #if defined(AHA152X_DEBUG) 1846 if (HOSTDATA(shpnt)->debug & debug_msgi) { 1847 printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0)); 1848 scsi_print_msg(&MSGI(0)); 1849 printk("\n"); 1850 } 1851 #endif 1852 1853 if(!CURRENT_SC) { 1854 if(LASTSTATE!=seldi) { 1855 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO); 1856 } 1857 1858 /* 1859 * Handle reselection 1860 */ 1861 if(!(MSGI(0) & IDENTIFY_BASE)) { 1862 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO); 1863 continue; 1864 } 1865 1866 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f); 1867 1868 if (!CURRENT_SC) { 1869 show_queues(shpnt); 1870 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f); 1871 continue; 1872 } 1873 1874 DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC)); 1875 1876 CURRENT_SC->SCp.Message = MSGI(0); 1877 CURRENT_SC->SCp.phase &= ~disconnected; 1878 1879 MSGILEN=0; 1880 1881 /* next message if any */ 1882 continue; 1883 } 1884 1885 CURRENT_SC->SCp.Message = MSGI(0); 1886 1887 switch (MSGI(0)) { 1888 case DISCONNECT: 1889 if (!RECONNECT) 1890 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC)); 1891 1892 CURRENT_SC->SCp.phase |= disconnected; 1893 break; 1894 1895 case COMMAND_COMPLETE: 1896 if(CURRENT_SC->SCp.phase & completed) 1897 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC)); 1898 1899 CURRENT_SC->SCp.phase |= completed; 1900 break; 1901 1902 case MESSAGE_REJECT: 1903 if (SYNCNEG==1) { 1904 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC)); 1905 SYNCNEG=2; /* negotiation completed */ 1906 } else 1907 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC)); 1908 break; 1909 1910 case SAVE_POINTERS: 1911 break; 1912 1913 case RESTORE_POINTERS: 1914 break; 1915 1916 case EXTENDED_MESSAGE: 1917 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) { 1918 /* not yet completed */ 1919 continue; 1920 } 1921 1922 switch (MSGI(2)) { 1923 case EXTENDED_SDTR: 1924 { 1925 long ticks; 1926 1927 if (MSGI(1) != 3) { 1928 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC)); 1929 break; 1930 } 1931 1932 if (!HOSTDATA(shpnt)->synchronous) 1933 break; 1934 1935 printk(INFO_LEAD, CMDINFO(CURRENT_SC)); 1936 scsi_print_msg(&MSGI(0)); 1937 printk("\n"); 1938 1939 ticks = (MSGI(3) * 4 + 49) / 50; 1940 1941 if (syncneg) { 1942 /* negotiation in progress */ 1943 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) { 1944 ADDMSGO(MESSAGE_REJECT); 1945 printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC)); 1946 break; 1947 } 1948 1949 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4); 1950 } else if (ticks <= 9 && MSGI(4) >= 1) { 1951 ADDMSGO(EXTENDED_MESSAGE); 1952 ADDMSGO(3); 1953 ADDMSGO(EXTENDED_SDTR); 1954 if (ticks < 4) { 1955 ticks = 4; 1956 ADDMSGO(50); 1957 } else 1958 ADDMSGO(MSGI(3)); 1959 1960 if (MSGI(4) > 8) 1961 MSGI(4) = 8; 1962 1963 ADDMSGO(MSGI(4)); 1964 1965 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4); 1966 } else { 1967 /* requested SDTR is too slow, do it asynchronously */ 1968 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC)); 1969 ADDMSGO(MESSAGE_REJECT); 1970 } 1971 1972 SYNCNEG=2; /* negotiation completed */ 1973 SETRATE(SYNCRATE); 1974 } 1975 break; 1976 1977 case BUS_DEVICE_RESET: 1978 { 1979 int i; 1980 1981 for(i=0; i<8; i++) { 1982 HOSTDATA(shpnt)->syncrate[i]=0; 1983 HOSTDATA(shpnt)->syncneg[i]=0; 1984 } 1985 1986 } 1987 break; 1988 1989 case EXTENDED_MODIFY_DATA_POINTER: 1990 case EXTENDED_EXTENDED_IDENTIFY: 1991 case EXTENDED_WDTR: 1992 default: 1993 ADDMSGO(MESSAGE_REJECT); 1994 break; 1995 } 1996 break; 1997 } 1998 1999 MSGILEN=0; 2000 } 2001 } 2002 2003 static void msgi_end(struct Scsi_Host *shpnt) 2004 { 2005 if(MSGILEN>0) 2006 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN); 2007 2008 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) { 2009 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC)); 2010 SETPORT(SCSISIG, P_MSGI | SIG_ATNO); 2011 } 2012 } 2013 2014 /* 2015 * message out phase 2016 * 2017 */ 2018 static void msgo_init(struct Scsi_Host *shpnt) 2019 { 2020 if(MSGOLEN==0) { 2021 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) { 2022 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun)); 2023 } else { 2024 printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC)); 2025 ADDMSGO(MESSAGE_REJECT); 2026 } 2027 } 2028 2029 #if defined(AHA152X_DEBUG) 2030 if(HOSTDATA(shpnt)->debug & debug_msgo) { 2031 int i; 2032 2033 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC)); 2034 for (i=0; i<MSGOLEN; i+=scsi_print_msg(&MSGO(i)), printk(" ")) 2035 ; 2036 printk(")\n"); 2037 } 2038 #endif 2039 } 2040 2041 /* 2042 * message out phase 2043 * 2044 */ 2045 static void msgo_run(struct Scsi_Host *shpnt) 2046 { 2047 if(MSGO_I==MSGOLEN) 2048 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN); 2049 2050 while(MSGO_I<MSGOLEN) { 2051 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN); 2052 2053 if(TESTLO(SSTAT0, SPIORDY)) { 2054 DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC)); 2055 return; 2056 } 2057 2058 if (MSGO_I==MSGOLEN-1) { 2059 /* Leave MESSAGE OUT after transfer */ 2060 SETPORT(SSTAT1, CLRATNO); 2061 } 2062 2063 2064 if (MSGO(MSGO_I) & IDENTIFY_BASE) 2065 CURRENT_SC->SCp.phase |= identified; 2066 2067 if (MSGO(MSGO_I)==ABORT) 2068 CURRENT_SC->SCp.phase |= aborted; 2069 2070 if (MSGO(MSGO_I)==BUS_DEVICE_RESET) 2071 CURRENT_SC->SCp.phase |= resetted; 2072 2073 SETPORT(SCSIDAT, MSGO(MSGO_I++)); 2074 } 2075 } 2076 2077 static void msgo_end(struct Scsi_Host *shpnt) 2078 { 2079 if(MSGO_I<MSGOLEN) { 2080 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN); 2081 if(SYNCNEG==1) { 2082 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC)); 2083 SYNCNEG=2; 2084 } 2085 } 2086 2087 MSGO_I = 0; 2088 MSGOLEN = 0; 2089 } 2090 2091 /* 2092 * command phase 2093 * 2094 */ 2095 static void cmd_init(struct Scsi_Host *shpnt) 2096 { 2097 if (CURRENT_SC->SCp.sent_command) { 2098 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC)); 2099 done(shpnt, DID_ERROR << 16); 2100 return; 2101 } 2102 2103 #if defined(AHA152X_DEBUG) 2104 if (HOSTDATA(shpnt)->debug & debug_cmd) { 2105 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC)); 2106 __scsi_print_command(CURRENT_SC->cmnd); 2107 } 2108 #endif 2109 2110 CMD_I=0; 2111 } 2112 2113 /* 2114 * command phase 2115 * 2116 */ 2117 static void cmd_run(struct Scsi_Host *shpnt) 2118 { 2119 if(CMD_I==CURRENT_SC->cmd_len) { 2120 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len); 2121 disp_ports(shpnt); 2122 } 2123 2124 while(CMD_I<CURRENT_SC->cmd_len) { 2125 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); 2126 2127 if(TESTLO(SSTAT0, SPIORDY)) { 2128 DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC)); 2129 return; 2130 } 2131 2132 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]); 2133 } 2134 } 2135 2136 static void cmd_end(struct Scsi_Host *shpnt) 2137 { 2138 if(CMD_I<CURRENT_SC->cmd_len) 2139 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len); 2140 else 2141 CURRENT_SC->SCp.sent_command++; 2142 } 2143 2144 /* 2145 * status phase 2146 * 2147 */ 2148 static void status_run(struct Scsi_Host *shpnt) 2149 { 2150 if(TESTLO(SSTAT0,SPIORDY)) { 2151 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC)); 2152 return; 2153 } 2154 2155 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT); 2156 2157 #if defined(AHA152X_DEBUG) 2158 if (HOSTDATA(shpnt)->debug & debug_status) { 2159 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status); 2160 scsi_print_status(CURRENT_SC->SCp.Status); 2161 printk("\n"); 2162 } 2163 #endif 2164 } 2165 2166 /* 2167 * data in phase 2168 * 2169 */ 2170 static void datai_init(struct Scsi_Host *shpnt) 2171 { 2172 SETPORT(DMACNTRL0, RSTFIFO); 2173 SETPORT(DMACNTRL0, RSTFIFO|ENDMA); 2174 2175 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 2176 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN); 2177 2178 SETPORT(SIMODE0, 0); 2179 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE); 2180 2181 DATA_LEN=0; 2182 DPRINTK(debug_datai, 2183 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n", 2184 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid); 2185 } 2186 2187 static void datai_run(struct Scsi_Host *shpnt) 2188 { 2189 unsigned long the_time; 2190 int fifodata, data_count; 2191 2192 /* 2193 * loop while the phase persists or the fifos are not empty 2194 * 2195 */ 2196 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) { 2197 /* FIXME: maybe this should be done by setting up 2198 * STCNT to trigger ENSWRAP interrupt, instead of 2199 * polling for DFIFOFULL 2200 */ 2201 the_time=jiffies + 100*HZ; 2202 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time)) 2203 barrier(); 2204 2205 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) { 2206 printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC)); 2207 disp_ports(shpnt); 2208 break; 2209 } 2210 2211 if(TESTHI(DMASTAT, DFIFOFULL)) { 2212 fifodata = 128; 2213 } else { 2214 the_time=jiffies + 100*HZ; 2215 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time)) 2216 barrier(); 2217 2218 if(TESTLO(SSTAT2, SEMPTY)) { 2219 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC)); 2220 disp_ports(shpnt); 2221 break; 2222 } 2223 2224 fifodata = GETPORT(FIFOSTAT); 2225 } 2226 2227 if(CURRENT_SC->SCp.this_residual>0) { 2228 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) { 2229 data_count = fifodata>CURRENT_SC->SCp.this_residual ? 2230 CURRENT_SC->SCp.this_residual : 2231 fifodata; 2232 fifodata -= data_count; 2233 2234 if(data_count & 1) { 2235 DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC)); 2236 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2237 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT); 2238 CURRENT_SC->SCp.this_residual--; 2239 DATA_LEN++; 2240 SETPORT(DMACNTRL0, ENDMA); 2241 } 2242 2243 if(data_count > 1) { 2244 DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count); 2245 data_count >>= 1; 2246 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count); 2247 CURRENT_SC->SCp.ptr += 2 * data_count; 2248 CURRENT_SC->SCp.this_residual -= 2 * data_count; 2249 DATA_LEN += 2 * data_count; 2250 } 2251 2252 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) { 2253 /* advance to next buffer */ 2254 CURRENT_SC->SCp.buffers_residual--; 2255 CURRENT_SC->SCp.buffer++; 2256 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer); 2257 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length; 2258 } 2259 } 2260 } else if(fifodata>0) { 2261 printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT)); 2262 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2263 while(fifodata>0) { 2264 int data; 2265 data=GETPORT(DATAPORT); 2266 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data); 2267 fifodata--; 2268 DATA_LEN++; 2269 } 2270 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2271 } 2272 } 2273 2274 if(TESTLO(DMASTAT, INTSTAT) || 2275 TESTLO(DMASTAT, DFIFOEMP) || 2276 TESTLO(SSTAT2, SEMPTY) || 2277 GETPORT(FIFOSTAT)>0) { 2278 /* 2279 * something went wrong, if there's something left in the fifos 2280 * or the phase didn't change 2281 */ 2282 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC)); 2283 disp_ports(shpnt); 2284 } 2285 2286 if(DATA_LEN!=GETSTCNT()) { 2287 printk(ERR_LEAD 2288 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)", 2289 CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT)); 2290 disp_ports(shpnt); 2291 mdelay(10000); 2292 } 2293 } 2294 2295 static void datai_end(struct Scsi_Host *shpnt) 2296 { 2297 CURRENT_SC->resid -= GETSTCNT(); 2298 2299 DPRINTK(debug_datai, 2300 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n", 2301 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid, GETSTCNT()); 2302 2303 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 2304 SETPORT(DMACNTRL0, 0); 2305 } 2306 2307 /* 2308 * data out phase 2309 * 2310 */ 2311 static void datao_init(struct Scsi_Host *shpnt) 2312 { 2313 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO); 2314 SETPORT(DMACNTRL0, WRITE_READ | ENDMA); 2315 2316 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 2317 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN); 2318 2319 SETPORT(SIMODE0, 0); 2320 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE ); 2321 2322 DATA_LEN = CURRENT_SC->resid; 2323 2324 DPRINTK(debug_datao, 2325 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n", 2326 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid); 2327 } 2328 2329 static void datao_run(struct Scsi_Host *shpnt) 2330 { 2331 unsigned long the_time; 2332 int data_count; 2333 2334 /* until phase changes or all data sent */ 2335 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) { 2336 data_count = 128; 2337 if(data_count > CURRENT_SC->SCp.this_residual) 2338 data_count=CURRENT_SC->SCp.this_residual; 2339 2340 if(TESTLO(DMASTAT, DFIFOEMP)) { 2341 printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT)); 2342 disp_ports(shpnt); 2343 break; 2344 } 2345 2346 if(data_count & 1) { 2347 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT); 2348 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++); 2349 CURRENT_SC->SCp.this_residual--; 2350 CURRENT_SC->resid--; 2351 SETPORT(DMACNTRL0,WRITE_READ|ENDMA); 2352 } 2353 2354 if(data_count > 1) { 2355 data_count >>= 1; 2356 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count); 2357 CURRENT_SC->SCp.ptr += 2 * data_count; 2358 CURRENT_SC->SCp.this_residual -= 2 * data_count; 2359 CURRENT_SC->resid -= 2 * data_count; 2360 } 2361 2362 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) { 2363 /* advance to next buffer */ 2364 CURRENT_SC->SCp.buffers_residual--; 2365 CURRENT_SC->SCp.buffer++; 2366 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer); 2367 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length; 2368 } 2369 2370 the_time=jiffies + 100*HZ; 2371 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time)) 2372 barrier(); 2373 2374 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) { 2375 printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC)); 2376 disp_ports(shpnt); 2377 break; 2378 } 2379 } 2380 } 2381 2382 static void datao_end(struct Scsi_Host *shpnt) 2383 { 2384 if(TESTLO(DMASTAT, DFIFOEMP)) { 2385 int data_count = (DATA_LEN - CURRENT_SC->resid) - GETSTCNT(); 2386 2387 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n", 2388 CMDINFO(CURRENT_SC), 2389 data_count, 2390 DATA_LEN-CURRENT_SC->resid, 2391 GETSTCNT()); 2392 2393 CURRENT_SC->resid += data_count; 2394 2395 if(CURRENT_SC->use_sg) { 2396 data_count -= CURRENT_SC->SCp.ptr - SG_ADDRESS(CURRENT_SC->SCp.buffer); 2397 while(data_count>0) { 2398 CURRENT_SC->SCp.buffer--; 2399 CURRENT_SC->SCp.buffers_residual++; 2400 data_count -= CURRENT_SC->SCp.buffer->length; 2401 } 2402 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) - data_count; 2403 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + data_count; 2404 } else { 2405 CURRENT_SC->SCp.ptr -= data_count; 2406 CURRENT_SC->SCp.this_residual += data_count; 2407 } 2408 } 2409 2410 DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n", 2411 CMDINFO(CURRENT_SC), 2412 CURRENT_SC->request_bufflen, 2413 CURRENT_SC->resid, 2414 GETSTCNT()); 2415 2416 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 2417 SETPORT(SXFRCTL0, CH1); 2418 2419 SETPORT(DMACNTRL0, 0); 2420 } 2421 2422 /* 2423 * figure out what state we're in 2424 * 2425 */ 2426 static int update_state(struct Scsi_Host *shpnt) 2427 { 2428 int dataphase=0; 2429 unsigned int stat0 = GETPORT(SSTAT0); 2430 unsigned int stat1 = GETPORT(SSTAT1); 2431 2432 PREVSTATE = STATE; 2433 STATE=unknown; 2434 2435 if(stat1 & SCSIRSTI) { 2436 STATE=rsti; 2437 SETPORT(SCSISEQ,0); 2438 SETPORT(SSTAT1,SCSIRSTI); 2439 } else if(stat0 & SELDI && PREVSTATE==busfree) { 2440 STATE=seldi; 2441 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) { 2442 STATE=seldo; 2443 } else if(stat1 & SELTO) { 2444 STATE=selto; 2445 } else if(stat1 & BUSFREE) { 2446 STATE=busfree; 2447 SETPORT(SSTAT1,BUSFREE); 2448 } else if(stat1 & SCSIPERR) { 2449 STATE=parerr; 2450 SETPORT(SSTAT1,SCSIPERR); 2451 } else if(stat1 & REQINIT) { 2452 switch(GETPORT(SCSISIG) & P_MASK) { 2453 case P_MSGI: STATE=msgi; break; 2454 case P_MSGO: STATE=msgo; break; 2455 case P_DATAO: STATE=datao; break; 2456 case P_DATAI: STATE=datai; break; 2457 case P_STATUS: STATE=status; break; 2458 case P_CMD: STATE=cmd; break; 2459 } 2460 dataphase=1; 2461 } 2462 2463 if((stat0 & SELDI) && STATE!=seldi && !dataphase) { 2464 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC)); 2465 disp_ports(shpnt); 2466 } 2467 2468 if(STATE!=PREVSTATE) { 2469 LASTSTATE=PREVSTATE; 2470 } 2471 2472 return dataphase; 2473 } 2474 2475 /* 2476 * handle parity error 2477 * 2478 * FIXME: in which phase? 2479 * 2480 */ 2481 static void parerr_run(struct Scsi_Host *shpnt) 2482 { 2483 printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC)); 2484 done(shpnt, DID_PARITY << 16); 2485 } 2486 2487 /* 2488 * handle reset in 2489 * 2490 */ 2491 static void rsti_run(struct Scsi_Host *shpnt) 2492 { 2493 Scsi_Cmnd *ptr; 2494 2495 printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO); 2496 2497 ptr=DISCONNECTED_SC; 2498 while(ptr) { 2499 Scsi_Cmnd *next = SCNEXT(ptr); 2500 2501 if (!ptr->device->soft_reset) { 2502 remove_SC(&DISCONNECTED_SC, ptr); 2503 2504 kfree(ptr->host_scribble); 2505 ptr->host_scribble=NULL; 2506 2507 ptr->result = DID_RESET << 16; 2508 ptr->scsi_done(ptr); 2509 } 2510 2511 ptr = next; 2512 } 2513 2514 if(CURRENT_SC && !CURRENT_SC->device->soft_reset) 2515 done(shpnt, DID_RESET << 16 ); 2516 } 2517 2518 2519 /* 2520 * bottom-half handler 2521 * 2522 */ 2523 static void is_complete(struct Scsi_Host *shpnt) 2524 { 2525 int dataphase; 2526 unsigned long flags; 2527 int pending; 2528 2529 DO_LOCK(flags); 2530 if(HOSTDATA(shpnt)->in_intr) { 2531 DO_UNLOCK(flags); 2532 /* aha152x_error never returns.. */ 2533 aha152x_error(shpnt, "bottom-half already running!?"); 2534 } 2535 HOSTDATA(shpnt)->in_intr++; 2536 2537 /* 2538 * loop while there are interrupt conditions pending 2539 * 2540 */ 2541 do { 2542 unsigned long start = jiffies; 2543 DO_UNLOCK(flags); 2544 2545 dataphase=update_state(shpnt); 2546 2547 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name); 2548 2549 /* 2550 * end previous state 2551 * 2552 */ 2553 if(PREVSTATE!=STATE && states[PREVSTATE].end) 2554 states[PREVSTATE].end(shpnt); 2555 2556 /* 2557 * disable SPIO mode if previous phase used it 2558 * and this one doesn't 2559 * 2560 */ 2561 if(states[PREVSTATE].spio && !states[STATE].spio) { 2562 SETPORT(SXFRCTL0, CH1); 2563 SETPORT(DMACNTRL0, 0); 2564 if(CURRENT_SC) 2565 CURRENT_SC->SCp.phase &= ~spiordy; 2566 } 2567 2568 /* 2569 * accept current dataphase phase 2570 * 2571 */ 2572 if(dataphase) { 2573 SETPORT(SSTAT0, REQINIT); 2574 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK); 2575 SETPORT(SSTAT1, PHASECHG); 2576 } 2577 2578 /* 2579 * enable SPIO mode if previous didn't use it 2580 * and this one does 2581 * 2582 */ 2583 if(!states[PREVSTATE].spio && states[STATE].spio) { 2584 SETPORT(DMACNTRL0, 0); 2585 SETPORT(SXFRCTL0, CH1|SPIOEN); 2586 if(CURRENT_SC) 2587 CURRENT_SC->SCp.phase |= spiordy; 2588 } 2589 2590 /* 2591 * initialize for new state 2592 * 2593 */ 2594 if(PREVSTATE!=STATE && states[STATE].init) 2595 states[STATE].init(shpnt); 2596 2597 /* 2598 * handle current state 2599 * 2600 */ 2601 if(states[STATE].run) 2602 states[STATE].run(shpnt); 2603 else 2604 printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE); 2605 2606 /* 2607 * setup controller to interrupt on 2608 * the next expected condition and 2609 * loop if it's already there 2610 * 2611 */ 2612 DO_LOCK(flags); 2613 pending=setup_expected_interrupts(shpnt); 2614 #if defined(AHA152X_STAT) 2615 HOSTDATA(shpnt)->count[STATE]++; 2616 if(PREVSTATE!=STATE) 2617 HOSTDATA(shpnt)->count_trans[STATE]++; 2618 HOSTDATA(shpnt)->time[STATE] += jiffies-start; 2619 #endif 2620 2621 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name); 2622 } while(pending); 2623 2624 /* 2625 * enable interrupts and leave bottom-half 2626 * 2627 */ 2628 HOSTDATA(shpnt)->in_intr--; 2629 SETBITS(DMACNTRL0, INTEN); 2630 DO_UNLOCK(flags); 2631 } 2632 2633 2634 /* 2635 * Dump the current driver status and panic 2636 */ 2637 static void aha152x_error(struct Scsi_Host *shpnt, char *msg) 2638 { 2639 printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg); 2640 show_queues(shpnt); 2641 panic("aha152x panic\n"); 2642 } 2643 2644 /* 2645 * Display registers of AIC-6260 2646 */ 2647 static void disp_ports(struct Scsi_Host *shpnt) 2648 { 2649 #if defined(AHA152X_DEBUG) 2650 int s; 2651 2652 printk("\n%s: %s(%s) ", 2653 CURRENT_SC ? "busy" : "waiting", 2654 states[STATE].name, 2655 states[PREVSTATE].name); 2656 2657 s = GETPORT(SCSISEQ); 2658 printk("SCSISEQ( "); 2659 if (s & TEMODEO) 2660 printk("TARGET MODE "); 2661 if (s & ENSELO) 2662 printk("SELO "); 2663 if (s & ENSELI) 2664 printk("SELI "); 2665 if (s & ENRESELI) 2666 printk("RESELI "); 2667 if (s & ENAUTOATNO) 2668 printk("AUTOATNO "); 2669 if (s & ENAUTOATNI) 2670 printk("AUTOATNI "); 2671 if (s & ENAUTOATNP) 2672 printk("AUTOATNP "); 2673 if (s & SCSIRSTO) 2674 printk("SCSIRSTO "); 2675 printk(");"); 2676 2677 printk(" SCSISIG("); 2678 s = GETPORT(SCSISIG); 2679 switch (s & P_MASK) { 2680 case P_DATAO: 2681 printk("DATA OUT"); 2682 break; 2683 case P_DATAI: 2684 printk("DATA IN"); 2685 break; 2686 case P_CMD: 2687 printk("COMMAND"); 2688 break; 2689 case P_STATUS: 2690 printk("STATUS"); 2691 break; 2692 case P_MSGO: 2693 printk("MESSAGE OUT"); 2694 break; 2695 case P_MSGI: 2696 printk("MESSAGE IN"); 2697 break; 2698 default: 2699 printk("*invalid*"); 2700 break; 2701 } 2702 2703 printk("); "); 2704 2705 printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo"); 2706 2707 printk("SSTAT( "); 2708 s = GETPORT(SSTAT0); 2709 if (s & TARGET) 2710 printk("TARGET "); 2711 if (s & SELDO) 2712 printk("SELDO "); 2713 if (s & SELDI) 2714 printk("SELDI "); 2715 if (s & SELINGO) 2716 printk("SELINGO "); 2717 if (s & SWRAP) 2718 printk("SWRAP "); 2719 if (s & SDONE) 2720 printk("SDONE "); 2721 if (s & SPIORDY) 2722 printk("SPIORDY "); 2723 if (s & DMADONE) 2724 printk("DMADONE "); 2725 2726 s = GETPORT(SSTAT1); 2727 if (s & SELTO) 2728 printk("SELTO "); 2729 if (s & ATNTARG) 2730 printk("ATNTARG "); 2731 if (s & SCSIRSTI) 2732 printk("SCSIRSTI "); 2733 if (s & PHASEMIS) 2734 printk("PHASEMIS "); 2735 if (s & BUSFREE) 2736 printk("BUSFREE "); 2737 if (s & SCSIPERR) 2738 printk("SCSIPERR "); 2739 if (s & PHASECHG) 2740 printk("PHASECHG "); 2741 if (s & REQINIT) 2742 printk("REQINIT "); 2743 printk("); "); 2744 2745 2746 printk("SSTAT( "); 2747 2748 s = GETPORT(SSTAT0) & GETPORT(SIMODE0); 2749 2750 if (s & TARGET) 2751 printk("TARGET "); 2752 if (s & SELDO) 2753 printk("SELDO "); 2754 if (s & SELDI) 2755 printk("SELDI "); 2756 if (s & SELINGO) 2757 printk("SELINGO "); 2758 if (s & SWRAP) 2759 printk("SWRAP "); 2760 if (s & SDONE) 2761 printk("SDONE "); 2762 if (s & SPIORDY) 2763 printk("SPIORDY "); 2764 if (s & DMADONE) 2765 printk("DMADONE "); 2766 2767 s = GETPORT(SSTAT1) & GETPORT(SIMODE1); 2768 2769 if (s & SELTO) 2770 printk("SELTO "); 2771 if (s & ATNTARG) 2772 printk("ATNTARG "); 2773 if (s & SCSIRSTI) 2774 printk("SCSIRSTI "); 2775 if (s & PHASEMIS) 2776 printk("PHASEMIS "); 2777 if (s & BUSFREE) 2778 printk("BUSFREE "); 2779 if (s & SCSIPERR) 2780 printk("SCSIPERR "); 2781 if (s & PHASECHG) 2782 printk("PHASECHG "); 2783 if (s & REQINIT) 2784 printk("REQINIT "); 2785 printk("); "); 2786 2787 printk("SXFRCTL0( "); 2788 2789 s = GETPORT(SXFRCTL0); 2790 if (s & SCSIEN) 2791 printk("SCSIEN "); 2792 if (s & DMAEN) 2793 printk("DMAEN "); 2794 if (s & CH1) 2795 printk("CH1 "); 2796 if (s & CLRSTCNT) 2797 printk("CLRSTCNT "); 2798 if (s & SPIOEN) 2799 printk("SPIOEN "); 2800 if (s & CLRCH1) 2801 printk("CLRCH1 "); 2802 printk("); "); 2803 2804 printk("SIGNAL( "); 2805 2806 s = GETPORT(SCSISIG); 2807 if (s & SIG_ATNI) 2808 printk("ATNI "); 2809 if (s & SIG_SELI) 2810 printk("SELI "); 2811 if (s & SIG_BSYI) 2812 printk("BSYI "); 2813 if (s & SIG_REQI) 2814 printk("REQI "); 2815 if (s & SIG_ACKI) 2816 printk("ACKI "); 2817 printk("); "); 2818 2819 printk("SELID (%02x), ", GETPORT(SELID)); 2820 2821 printk("STCNT (%d), ", GETSTCNT()); 2822 2823 printk("SSTAT2( "); 2824 2825 s = GETPORT(SSTAT2); 2826 if (s & SOFFSET) 2827 printk("SOFFSET "); 2828 if (s & SEMPTY) 2829 printk("SEMPTY "); 2830 if (s & SFULL) 2831 printk("SFULL "); 2832 printk("); SFCNT (%d); ", s & (SFULL | SFCNT)); 2833 2834 s = GETPORT(SSTAT3); 2835 printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f); 2836 2837 printk("SSTAT4( "); 2838 s = GETPORT(SSTAT4); 2839 if (s & SYNCERR) 2840 printk("SYNCERR "); 2841 if (s & FWERR) 2842 printk("FWERR "); 2843 if (s & FRERR) 2844 printk("FRERR "); 2845 printk("); "); 2846 2847 printk("DMACNTRL0( "); 2848 s = GETPORT(DMACNTRL0); 2849 printk("%s ", s & _8BIT ? "8BIT" : "16BIT"); 2850 printk("%s ", s & DMA ? "DMA" : "PIO"); 2851 printk("%s ", s & WRITE_READ ? "WRITE" : "READ"); 2852 if (s & ENDMA) 2853 printk("ENDMA "); 2854 if (s & INTEN) 2855 printk("INTEN "); 2856 if (s & RSTFIFO) 2857 printk("RSTFIFO "); 2858 if (s & SWINT) 2859 printk("SWINT "); 2860 printk("); "); 2861 2862 printk("DMASTAT( "); 2863 s = GETPORT(DMASTAT); 2864 if (s & ATDONE) 2865 printk("ATDONE "); 2866 if (s & WORDRDY) 2867 printk("WORDRDY "); 2868 if (s & DFIFOFULL) 2869 printk("DFIFOFULL "); 2870 if (s & DFIFOEMP) 2871 printk("DFIFOEMP "); 2872 printk(")\n"); 2873 #endif 2874 } 2875 2876 /* 2877 * display enabled interrupts 2878 */ 2879 static void disp_enintr(struct Scsi_Host *shpnt) 2880 { 2881 int s; 2882 2883 printk(KERN_DEBUG "enabled interrupts ( "); 2884 2885 s = GETPORT(SIMODE0); 2886 if (s & ENSELDO) 2887 printk("ENSELDO "); 2888 if (s & ENSELDI) 2889 printk("ENSELDI "); 2890 if (s & ENSELINGO) 2891 printk("ENSELINGO "); 2892 if (s & ENSWRAP) 2893 printk("ENSWRAP "); 2894 if (s & ENSDONE) 2895 printk("ENSDONE "); 2896 if (s & ENSPIORDY) 2897 printk("ENSPIORDY "); 2898 if (s & ENDMADONE) 2899 printk("ENDMADONE "); 2900 2901 s = GETPORT(SIMODE1); 2902 if (s & ENSELTIMO) 2903 printk("ENSELTIMO "); 2904 if (s & ENATNTARG) 2905 printk("ENATNTARG "); 2906 if (s & ENPHASEMIS) 2907 printk("ENPHASEMIS "); 2908 if (s & ENBUSFREE) 2909 printk("ENBUSFREE "); 2910 if (s & ENSCSIPERR) 2911 printk("ENSCSIPERR "); 2912 if (s & ENPHASECHG) 2913 printk("ENPHASECHG "); 2914 if (s & ENREQINIT) 2915 printk("ENREQINIT "); 2916 printk(")\n"); 2917 } 2918 2919 /* 2920 * Show the command data of a command 2921 */ 2922 static void show_command(Scsi_Cmnd *ptr) 2923 { 2924 printk(KERN_DEBUG "0x%08x: target=%d; lun=%d; cmnd=(", 2925 (unsigned int) ptr, ptr->device->id, ptr->device->lun); 2926 2927 __scsi_print_command(ptr->cmnd); 2928 2929 printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |", 2930 ptr->request_bufflen, ptr->resid); 2931 2932 if (ptr->SCp.phase & not_issued) 2933 printk("not issued|"); 2934 if (ptr->SCp.phase & selecting) 2935 printk("selecting|"); 2936 if (ptr->SCp.phase & identified) 2937 printk("identified|"); 2938 if (ptr->SCp.phase & disconnected) 2939 printk("disconnected|"); 2940 if (ptr->SCp.phase & completed) 2941 printk("completed|"); 2942 if (ptr->SCp.phase & spiordy) 2943 printk("spiordy|"); 2944 if (ptr->SCp.phase & syncneg) 2945 printk("syncneg|"); 2946 if (ptr->SCp.phase & aborted) 2947 printk("aborted|"); 2948 if (ptr->SCp.phase & resetted) 2949 printk("resetted|"); 2950 if( SCDATA(ptr) ) { 2951 printk("; next=0x%p\n", SCNEXT(ptr)); 2952 } else { 2953 printk("; next=(host scribble NULL)\n"); 2954 } 2955 } 2956 2957 /* 2958 * Dump the queued data 2959 */ 2960 static void show_queues(struct Scsi_Host *shpnt) 2961 { 2962 Scsi_Cmnd *ptr; 2963 unsigned long flags; 2964 2965 DO_LOCK(flags); 2966 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n"); 2967 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr)) 2968 show_command(ptr); 2969 DO_UNLOCK(flags); 2970 2971 printk(KERN_DEBUG "current_SC:\n"); 2972 if (CURRENT_SC) 2973 show_command(CURRENT_SC); 2974 else 2975 printk(KERN_DEBUG "none\n"); 2976 2977 printk(KERN_DEBUG "disconnected_SC:\n"); 2978 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL) 2979 show_command(ptr); 2980 2981 disp_ports(shpnt); 2982 disp_enintr(shpnt); 2983 } 2984 2985 #undef SPRINTF 2986 #define SPRINTF(args...) pos += sprintf(pos, ## args) 2987 2988 static int get_command(char *pos, Scsi_Cmnd * ptr) 2989 { 2990 char *start = pos; 2991 int i; 2992 2993 SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ", 2994 (unsigned int) ptr, ptr->device->id, ptr->device->lun); 2995 2996 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++) 2997 SPRINTF("0x%02x ", ptr->cmnd[i]); 2998 2999 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |", 3000 ptr->resid, ptr->SCp.this_residual, ptr->SCp.buffers_residual); 3001 3002 if (ptr->SCp.phase & not_issued) 3003 SPRINTF("not issued|"); 3004 if (ptr->SCp.phase & selecting) 3005 SPRINTF("selecting|"); 3006 if (ptr->SCp.phase & disconnected) 3007 SPRINTF("disconnected|"); 3008 if (ptr->SCp.phase & aborted) 3009 SPRINTF("aborted|"); 3010 if (ptr->SCp.phase & identified) 3011 SPRINTF("identified|"); 3012 if (ptr->SCp.phase & completed) 3013 SPRINTF("completed|"); 3014 if (ptr->SCp.phase & spiordy) 3015 SPRINTF("spiordy|"); 3016 if (ptr->SCp.phase & syncneg) 3017 SPRINTF("syncneg|"); 3018 SPRINTF("; next=0x%p\n", SCNEXT(ptr)); 3019 3020 return (pos - start); 3021 } 3022 3023 static int get_ports(struct Scsi_Host *shpnt, char *pos) 3024 { 3025 char *start = pos; 3026 int s; 3027 3028 SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name); 3029 3030 s = GETPORT(SCSISEQ); 3031 SPRINTF("SCSISEQ( "); 3032 if (s & TEMODEO) 3033 SPRINTF("TARGET MODE "); 3034 if (s & ENSELO) 3035 SPRINTF("SELO "); 3036 if (s & ENSELI) 3037 SPRINTF("SELI "); 3038 if (s & ENRESELI) 3039 SPRINTF("RESELI "); 3040 if (s & ENAUTOATNO) 3041 SPRINTF("AUTOATNO "); 3042 if (s & ENAUTOATNI) 3043 SPRINTF("AUTOATNI "); 3044 if (s & ENAUTOATNP) 3045 SPRINTF("AUTOATNP "); 3046 if (s & SCSIRSTO) 3047 SPRINTF("SCSIRSTO "); 3048 SPRINTF(");"); 3049 3050 SPRINTF(" SCSISIG("); 3051 s = GETPORT(SCSISIG); 3052 switch (s & P_MASK) { 3053 case P_DATAO: 3054 SPRINTF("DATA OUT"); 3055 break; 3056 case P_DATAI: 3057 SPRINTF("DATA IN"); 3058 break; 3059 case P_CMD: 3060 SPRINTF("COMMAND"); 3061 break; 3062 case P_STATUS: 3063 SPRINTF("STATUS"); 3064 break; 3065 case P_MSGO: 3066 SPRINTF("MESSAGE OUT"); 3067 break; 3068 case P_MSGI: 3069 SPRINTF("MESSAGE IN"); 3070 break; 3071 default: 3072 SPRINTF("*invalid*"); 3073 break; 3074 } 3075 3076 SPRINTF("); "); 3077 3078 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo"); 3079 3080 SPRINTF("SSTAT( "); 3081 s = GETPORT(SSTAT0); 3082 if (s & TARGET) 3083 SPRINTF("TARGET "); 3084 if (s & SELDO) 3085 SPRINTF("SELDO "); 3086 if (s & SELDI) 3087 SPRINTF("SELDI "); 3088 if (s & SELINGO) 3089 SPRINTF("SELINGO "); 3090 if (s & SWRAP) 3091 SPRINTF("SWRAP "); 3092 if (s & SDONE) 3093 SPRINTF("SDONE "); 3094 if (s & SPIORDY) 3095 SPRINTF("SPIORDY "); 3096 if (s & DMADONE) 3097 SPRINTF("DMADONE "); 3098 3099 s = GETPORT(SSTAT1); 3100 if (s & SELTO) 3101 SPRINTF("SELTO "); 3102 if (s & ATNTARG) 3103 SPRINTF("ATNTARG "); 3104 if (s & SCSIRSTI) 3105 SPRINTF("SCSIRSTI "); 3106 if (s & PHASEMIS) 3107 SPRINTF("PHASEMIS "); 3108 if (s & BUSFREE) 3109 SPRINTF("BUSFREE "); 3110 if (s & SCSIPERR) 3111 SPRINTF("SCSIPERR "); 3112 if (s & PHASECHG) 3113 SPRINTF("PHASECHG "); 3114 if (s & REQINIT) 3115 SPRINTF("REQINIT "); 3116 SPRINTF("); "); 3117 3118 3119 SPRINTF("SSTAT( "); 3120 3121 s = GETPORT(SSTAT0) & GETPORT(SIMODE0); 3122 3123 if (s & TARGET) 3124 SPRINTF("TARGET "); 3125 if (s & SELDO) 3126 SPRINTF("SELDO "); 3127 if (s & SELDI) 3128 SPRINTF("SELDI "); 3129 if (s & SELINGO) 3130 SPRINTF("SELINGO "); 3131 if (s & SWRAP) 3132 SPRINTF("SWRAP "); 3133 if (s & SDONE) 3134 SPRINTF("SDONE "); 3135 if (s & SPIORDY) 3136 SPRINTF("SPIORDY "); 3137 if (s & DMADONE) 3138 SPRINTF("DMADONE "); 3139 3140 s = GETPORT(SSTAT1) & GETPORT(SIMODE1); 3141 3142 if (s & SELTO) 3143 SPRINTF("SELTO "); 3144 if (s & ATNTARG) 3145 SPRINTF("ATNTARG "); 3146 if (s & SCSIRSTI) 3147 SPRINTF("SCSIRSTI "); 3148 if (s & PHASEMIS) 3149 SPRINTF("PHASEMIS "); 3150 if (s & BUSFREE) 3151 SPRINTF("BUSFREE "); 3152 if (s & SCSIPERR) 3153 SPRINTF("SCSIPERR "); 3154 if (s & PHASECHG) 3155 SPRINTF("PHASECHG "); 3156 if (s & REQINIT) 3157 SPRINTF("REQINIT "); 3158 SPRINTF("); "); 3159 3160 SPRINTF("SXFRCTL0( "); 3161 3162 s = GETPORT(SXFRCTL0); 3163 if (s & SCSIEN) 3164 SPRINTF("SCSIEN "); 3165 if (s & DMAEN) 3166 SPRINTF("DMAEN "); 3167 if (s & CH1) 3168 SPRINTF("CH1 "); 3169 if (s & CLRSTCNT) 3170 SPRINTF("CLRSTCNT "); 3171 if (s & SPIOEN) 3172 SPRINTF("SPIOEN "); 3173 if (s & CLRCH1) 3174 SPRINTF("CLRCH1 "); 3175 SPRINTF("); "); 3176 3177 SPRINTF("SIGNAL( "); 3178 3179 s = GETPORT(SCSISIG); 3180 if (s & SIG_ATNI) 3181 SPRINTF("ATNI "); 3182 if (s & SIG_SELI) 3183 SPRINTF("SELI "); 3184 if (s & SIG_BSYI) 3185 SPRINTF("BSYI "); 3186 if (s & SIG_REQI) 3187 SPRINTF("REQI "); 3188 if (s & SIG_ACKI) 3189 SPRINTF("ACKI "); 3190 SPRINTF("); "); 3191 3192 SPRINTF("SELID(%02x), ", GETPORT(SELID)); 3193 3194 SPRINTF("STCNT(%d), ", GETSTCNT()); 3195 3196 SPRINTF("SSTAT2( "); 3197 3198 s = GETPORT(SSTAT2); 3199 if (s & SOFFSET) 3200 SPRINTF("SOFFSET "); 3201 if (s & SEMPTY) 3202 SPRINTF("SEMPTY "); 3203 if (s & SFULL) 3204 SPRINTF("SFULL "); 3205 SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT)); 3206 3207 s = GETPORT(SSTAT3); 3208 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f); 3209 3210 SPRINTF("SSTAT4( "); 3211 s = GETPORT(SSTAT4); 3212 if (s & SYNCERR) 3213 SPRINTF("SYNCERR "); 3214 if (s & FWERR) 3215 SPRINTF("FWERR "); 3216 if (s & FRERR) 3217 SPRINTF("FRERR "); 3218 SPRINTF("); "); 3219 3220 SPRINTF("DMACNTRL0( "); 3221 s = GETPORT(DMACNTRL0); 3222 SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT"); 3223 SPRINTF("%s ", s & DMA ? "DMA" : "PIO"); 3224 SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ"); 3225 if (s & ENDMA) 3226 SPRINTF("ENDMA "); 3227 if (s & INTEN) 3228 SPRINTF("INTEN "); 3229 if (s & RSTFIFO) 3230 SPRINTF("RSTFIFO "); 3231 if (s & SWINT) 3232 SPRINTF("SWINT "); 3233 SPRINTF("); "); 3234 3235 SPRINTF("DMASTAT( "); 3236 s = GETPORT(DMASTAT); 3237 if (s & ATDONE) 3238 SPRINTF("ATDONE "); 3239 if (s & WORDRDY) 3240 SPRINTF("WORDRDY "); 3241 if (s & DFIFOFULL) 3242 SPRINTF("DFIFOFULL "); 3243 if (s & DFIFOEMP) 3244 SPRINTF("DFIFOEMP "); 3245 SPRINTF(")\n"); 3246 3247 SPRINTF("enabled interrupts( "); 3248 3249 s = GETPORT(SIMODE0); 3250 if (s & ENSELDO) 3251 SPRINTF("ENSELDO "); 3252 if (s & ENSELDI) 3253 SPRINTF("ENSELDI "); 3254 if (s & ENSELINGO) 3255 SPRINTF("ENSELINGO "); 3256 if (s & ENSWRAP) 3257 SPRINTF("ENSWRAP "); 3258 if (s & ENSDONE) 3259 SPRINTF("ENSDONE "); 3260 if (s & ENSPIORDY) 3261 SPRINTF("ENSPIORDY "); 3262 if (s & ENDMADONE) 3263 SPRINTF("ENDMADONE "); 3264 3265 s = GETPORT(SIMODE1); 3266 if (s & ENSELTIMO) 3267 SPRINTF("ENSELTIMO "); 3268 if (s & ENATNTARG) 3269 SPRINTF("ENATNTARG "); 3270 if (s & ENPHASEMIS) 3271 SPRINTF("ENPHASEMIS "); 3272 if (s & ENBUSFREE) 3273 SPRINTF("ENBUSFREE "); 3274 if (s & ENSCSIPERR) 3275 SPRINTF("ENSCSIPERR "); 3276 if (s & ENPHASECHG) 3277 SPRINTF("ENPHASECHG "); 3278 if (s & ENREQINIT) 3279 SPRINTF("ENREQINIT "); 3280 SPRINTF(")\n"); 3281 3282 return (pos - start); 3283 } 3284 3285 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt) 3286 { 3287 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0) 3288 return -EINVAL; 3289 3290 #if defined(AHA152X_DEBUG) 3291 if(length>14 && strncmp("debug ", buffer+8, 6)==0) { 3292 int debug = HOSTDATA(shpnt)->debug; 3293 3294 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0); 3295 3296 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug); 3297 } else 3298 #endif 3299 #if defined(AHA152X_STAT) 3300 if(length>13 && strncmp("reset", buffer+8, 5)==0) { 3301 int i; 3302 3303 HOSTDATA(shpnt)->total_commands=0; 3304 HOSTDATA(shpnt)->disconnections=0; 3305 HOSTDATA(shpnt)->busfree_without_any_action=0; 3306 HOSTDATA(shpnt)->busfree_without_old_command=0; 3307 HOSTDATA(shpnt)->busfree_without_new_command=0; 3308 HOSTDATA(shpnt)->busfree_without_done_command=0; 3309 HOSTDATA(shpnt)->busfree_with_check_condition=0; 3310 for (i = idle; i<maxstate; i++) { 3311 HOSTDATA(shpnt)->count[i]=0; 3312 HOSTDATA(shpnt)->count_trans[i]=0; 3313 HOSTDATA(shpnt)->time[i]=0; 3314 } 3315 3316 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO); 3317 3318 } else 3319 #endif 3320 { 3321 return -EINVAL; 3322 } 3323 3324 3325 return length; 3326 } 3327 3328 #undef SPRINTF 3329 #define SPRINTF(args...) \ 3330 do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0) 3331 3332 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start, 3333 off_t offset, int length, int inout) 3334 { 3335 int i; 3336 char *pos = buffer; 3337 Scsi_Cmnd *ptr; 3338 unsigned long flags; 3339 int thislength; 3340 3341 DPRINTK(debug_procinfo, 3342 KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n", 3343 buffer, offset, length, shpnt->host_no, inout); 3344 3345 3346 if (inout) 3347 return aha152x_set_info(buffer, length, shpnt); 3348 3349 SPRINTF(AHA152X_REVID "\n"); 3350 3351 SPRINTF("ioports 0x%04lx to 0x%04lx\n", 3352 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1); 3353 SPRINTF("interrupt 0x%02x\n", shpnt->irq); 3354 SPRINTF("disconnection/reconnection %s\n", 3355 RECONNECT ? "enabled" : "disabled"); 3356 SPRINTF("parity checking %s\n", 3357 PARITY ? "enabled" : "disabled"); 3358 SPRINTF("synchronous transfers %s\n", 3359 SYNCHRONOUS ? "enabled" : "disabled"); 3360 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands); 3361 3362 if(SYNCHRONOUS) { 3363 SPRINTF("synchronously operating targets (tick=50 ns):\n"); 3364 for (i = 0; i < 8; i++) 3365 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f) 3366 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n", 3367 i, 3368 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2), 3369 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50, 3370 HOSTDATA(shpnt)->syncrate[i] & 0x0f); 3371 } 3372 #if defined(AHA152X_DEBUG) 3373 #define PDEBUG(flags,txt) \ 3374 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt); 3375 3376 SPRINTF("enabled debugging options: "); 3377 3378 PDEBUG(debug_procinfo, "procinfo"); 3379 PDEBUG(debug_queue, "queue"); 3380 PDEBUG(debug_intr, "interrupt"); 3381 PDEBUG(debug_selection, "selection"); 3382 PDEBUG(debug_msgo, "message out"); 3383 PDEBUG(debug_msgi, "message in"); 3384 PDEBUG(debug_status, "status"); 3385 PDEBUG(debug_cmd, "command"); 3386 PDEBUG(debug_datai, "data in"); 3387 PDEBUG(debug_datao, "data out"); 3388 PDEBUG(debug_eh, "eh"); 3389 PDEBUG(debug_locks, "locks"); 3390 PDEBUG(debug_phases, "phases"); 3391 3392 SPRINTF("\n"); 3393 #endif 3394 3395 SPRINTF("\nqueue status:\n"); 3396 DO_LOCK(flags); 3397 if (ISSUE_SC) { 3398 SPRINTF("not yet issued commands:\n"); 3399 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr)) 3400 pos += get_command(pos, ptr); 3401 } else 3402 SPRINTF("no not yet issued commands\n"); 3403 DO_UNLOCK(flags); 3404 3405 if (CURRENT_SC) { 3406 SPRINTF("current command:\n"); 3407 pos += get_command(pos, CURRENT_SC); 3408 } else 3409 SPRINTF("no current command\n"); 3410 3411 if (DISCONNECTED_SC) { 3412 SPRINTF("disconnected commands:\n"); 3413 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr)) 3414 pos += get_command(pos, ptr); 3415 } else 3416 SPRINTF("no disconnected commands\n"); 3417 3418 pos += get_ports(shpnt, pos); 3419 3420 #if defined(AHA152X_STAT) 3421 SPRINTF("statistics:\n" 3422 "total commands: %d\n" 3423 "disconnections: %d\n" 3424 "busfree with check condition: %d\n" 3425 "busfree without old command: %d\n" 3426 "busfree without new command: %d\n" 3427 "busfree without done command: %d\n" 3428 "busfree without any action: %d\n" 3429 "state " 3430 "transitions " 3431 "count " 3432 "time\n", 3433 HOSTDATA(shpnt)->total_commands, 3434 HOSTDATA(shpnt)->disconnections, 3435 HOSTDATA(shpnt)->busfree_with_check_condition, 3436 HOSTDATA(shpnt)->busfree_without_old_command, 3437 HOSTDATA(shpnt)->busfree_without_new_command, 3438 HOSTDATA(shpnt)->busfree_without_done_command, 3439 HOSTDATA(shpnt)->busfree_without_any_action); 3440 for(i=0; i<maxstate; i++) { 3441 SPRINTF("%-10s %-12d %-12d %-12ld\n", 3442 states[i].name, 3443 HOSTDATA(shpnt)->count_trans[i], 3444 HOSTDATA(shpnt)->count[i], 3445 HOSTDATA(shpnt)->time[i]); 3446 } 3447 #endif 3448 3449 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos); 3450 3451 thislength = pos - (buffer + offset); 3452 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength); 3453 3454 if(thislength<0) { 3455 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n"); 3456 *start = NULL; 3457 return 0; 3458 } 3459 3460 thislength = thislength<length ? thislength : length; 3461 3462 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength); 3463 3464 *start = buffer + offset; 3465 return thislength < length ? thislength : length; 3466 } 3467 3468 static Scsi_Host_Template aha152x_driver_template = { 3469 .module = THIS_MODULE, 3470 .name = AHA152X_REVID, 3471 .proc_name = "aha152x", 3472 .proc_info = aha152x_proc_info, 3473 .queuecommand = aha152x_queue, 3474 .eh_abort_handler = aha152x_abort, 3475 .eh_device_reset_handler = aha152x_device_reset, 3476 .eh_bus_reset_handler = aha152x_bus_reset, 3477 .eh_host_reset_handler = aha152x_host_reset, 3478 .bios_param = aha152x_biosparam, 3479 .can_queue = 1, 3480 .this_id = 7, 3481 .sg_tablesize = SG_ALL, 3482 .cmd_per_lun = 1, 3483 .use_clustering = DISABLE_CLUSTERING, 3484 }; 3485 3486 #if !defined(PCMCIA) 3487 static int setup_count; 3488 static struct aha152x_setup setup[2]; 3489 3490 /* possible i/o addresses for the AIC-6260; default first */ 3491 static unsigned short ports[] = { 0x340, 0x140 }; 3492 3493 #if !defined(SKIP_BIOSTEST) 3494 /* possible locations for the Adaptec BIOS; defaults first */ 3495 static unsigned int addresses[] = 3496 { 3497 0xdc000, /* default first */ 3498 0xc8000, 3499 0xcc000, 3500 0xd0000, 3501 0xd4000, 3502 0xd8000, 3503 0xe0000, 3504 0xeb800, /* VTech Platinum SMP */ 3505 0xf0000, 3506 }; 3507 3508 /* signatures for various AIC-6[23]60 based controllers. 3509 The point in detecting signatures is to avoid useless and maybe 3510 harmful probes on ports. I'm not sure that all listed boards pass 3511 auto-configuration. For those which fail the BIOS signature is 3512 obsolete, because user intervention to supply the configuration is 3513 needed anyway. May be an information whether or not the BIOS supports 3514 extended translation could be also useful here. */ 3515 static struct signature { 3516 unsigned char *signature; 3517 int sig_offset; 3518 int sig_length; 3519 } signatures[] = 3520 { 3521 { "Adaptec AHA-1520 BIOS", 0x102e, 21 }, 3522 /* Adaptec 152x */ 3523 { "Adaptec AHA-1520B", 0x000b, 17 }, 3524 /* Adaptec 152x rev B */ 3525 { "Adaptec AHA-1520B", 0x0026, 17 }, 3526 /* Iomega Jaz Jet ISA (AIC6370Q) */ 3527 { "Adaptec ASW-B626 BIOS", 0x1029, 21 }, 3528 /* on-board controller */ 3529 { "Adaptec BIOS: ASW-B626", 0x000f, 22 }, 3530 /* on-board controller */ 3531 { "Adaptec ASW-B626 S2", 0x2e6c, 19 }, 3532 /* on-board controller */ 3533 { "Adaptec BIOS:AIC-6360", 0x000c, 21 }, 3534 /* on-board controller */ 3535 { "ScsiPro SP-360 BIOS", 0x2873, 19 }, 3536 /* ScsiPro-Controller */ 3537 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 }, 3538 /* Gigabyte Local-Bus-SCSI */ 3539 { "Adaptec BIOS:AVA-282X", 0x000c, 21 }, 3540 /* Adaptec 282x */ 3541 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 }, 3542 /* IBM Thinkpad Dock II */ 3543 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 }, 3544 /* IBM Thinkpad Dock II SCSI */ 3545 { "DTC3520A Host Adapter BIOS", 0x318a, 26 }, 3546 /* DTC 3520A ISA SCSI */ 3547 }; 3548 #endif /* !SKIP_BIOSTEST */ 3549 3550 /* 3551 * Test, if port_base is valid. 3552 * 3553 */ 3554 static int aha152x_porttest(int io_port) 3555 { 3556 int i; 3557 3558 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */ 3559 for (i = 0; i < 16; i++) 3560 SETPORT(io_port + O_STACK, i); 3561 3562 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */ 3563 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++) 3564 ; 3565 3566 return (i == 16); 3567 } 3568 3569 static int tc1550_porttest(int io_port) 3570 { 3571 int i; 3572 3573 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */ 3574 for (i = 0; i < 16; i++) 3575 SETPORT(io_port + O_STACK, i); 3576 3577 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */ 3578 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++) 3579 ; 3580 3581 return (i == 16); 3582 } 3583 3584 3585 static int checksetup(struct aha152x_setup *setup) 3586 { 3587 int i; 3588 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++) 3589 ; 3590 3591 if (i == ARRAY_SIZE(ports)) 3592 return 0; 3593 3594 if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) { 3595 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port); 3596 return 0; 3597 } 3598 3599 if( aha152x_porttest(setup->io_port) ) { 3600 setup->tc1550=0; 3601 } else if( tc1550_porttest(setup->io_port) ) { 3602 setup->tc1550=1; 3603 } else { 3604 release_region(setup->io_port, IO_RANGE); 3605 return 0; 3606 } 3607 3608 release_region(setup->io_port, IO_RANGE); 3609 3610 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX)) 3611 return 0; 3612 3613 if ((setup->scsiid < 0) || (setup->scsiid > 7)) 3614 return 0; 3615 3616 if ((setup->reconnect < 0) || (setup->reconnect > 1)) 3617 return 0; 3618 3619 if ((setup->parity < 0) || (setup->parity > 1)) 3620 return 0; 3621 3622 if ((setup->synchronous < 0) || (setup->synchronous > 1)) 3623 return 0; 3624 3625 if ((setup->ext_trans < 0) || (setup->ext_trans > 1)) 3626 return 0; 3627 3628 3629 return 1; 3630 } 3631 3632 3633 static int __init aha152x_init(void) 3634 { 3635 int i, j, ok; 3636 #if defined(AUTOCONF) 3637 aha152x_config conf; 3638 #endif 3639 #ifdef __ISAPNP__ 3640 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL}; 3641 #endif 3642 3643 if ( setup_count ) { 3644 printk(KERN_INFO "aha152x: processing commandline: "); 3645 3646 for (i = 0; i<setup_count; i++) { 3647 if (!checksetup(&setup[i])) { 3648 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf); 3649 printk(KERN_ERR "aha152x: invalid line\n"); 3650 } 3651 } 3652 printk("ok\n"); 3653 } 3654 3655 #if defined(SETUP0) 3656 if (setup_count < ARRAY_SIZE(setup)) { 3657 struct aha152x_setup override = SETUP0; 3658 3659 if (setup_count == 0 || (override.io_port != setup[0].io_port)) { 3660 if (!checksetup(&override)) { 3661 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n", 3662 override.io_port, 3663 override.irq, 3664 override.scsiid, 3665 override.reconnect, 3666 override.parity, 3667 override.synchronous, 3668 override.delay, 3669 override.ext_trans); 3670 } else 3671 setup[setup_count++] = override; 3672 } 3673 } 3674 #endif 3675 3676 #if defined(SETUP1) 3677 if (setup_count < ARRAY_SIZE(setup)) { 3678 struct aha152x_setup override = SETUP1; 3679 3680 if (setup_count == 0 || (override.io_port != setup[0].io_port)) { 3681 if (!checksetup(&override)) { 3682 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n", 3683 override.io_port, 3684 override.irq, 3685 override.scsiid, 3686 override.reconnect, 3687 override.parity, 3688 override.synchronous, 3689 override.delay, 3690 override.ext_trans); 3691 } else 3692 setup[setup_count++] = override; 3693 } 3694 } 3695 #endif 3696 3697 #if defined(MODULE) 3698 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) { 3699 if(aha152x[0]!=0) { 3700 setup[setup_count].conf = ""; 3701 setup[setup_count].io_port = aha152x[0]; 3702 setup[setup_count].irq = aha152x[1]; 3703 setup[setup_count].scsiid = aha152x[2]; 3704 setup[setup_count].reconnect = aha152x[3]; 3705 setup[setup_count].parity = aha152x[4]; 3706 setup[setup_count].synchronous = aha152x[5]; 3707 setup[setup_count].delay = aha152x[6]; 3708 setup[setup_count].ext_trans = aha152x[7]; 3709 #if defined(AHA152X_DEBUG) 3710 setup[setup_count].debug = aha152x[8]; 3711 #endif 3712 } else if(io[0]!=0 || irq[0]!=0) { 3713 if(io[0]!=0) setup[setup_count].io_port = io[0]; 3714 if(irq[0]!=0) setup[setup_count].irq = irq[0]; 3715 3716 setup[setup_count].scsiid = scsiid[0]; 3717 setup[setup_count].reconnect = reconnect[0]; 3718 setup[setup_count].parity = parity[0]; 3719 setup[setup_count].synchronous = sync[0]; 3720 setup[setup_count].delay = delay[0]; 3721 setup[setup_count].ext_trans = exttrans[0]; 3722 #if defined(AHA152X_DEBUG) 3723 setup[setup_count].debug = debug[0]; 3724 #endif 3725 } 3726 3727 if (checksetup(&setup[setup_count])) 3728 setup_count++; 3729 else 3730 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", 3731 setup[setup_count].io_port, 3732 setup[setup_count].irq, 3733 setup[setup_count].scsiid, 3734 setup[setup_count].reconnect, 3735 setup[setup_count].parity, 3736 setup[setup_count].synchronous, 3737 setup[setup_count].delay, 3738 setup[setup_count].ext_trans); 3739 } 3740 3741 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) { 3742 if(aha152x1[0]!=0) { 3743 setup[setup_count].conf = ""; 3744 setup[setup_count].io_port = aha152x1[0]; 3745 setup[setup_count].irq = aha152x1[1]; 3746 setup[setup_count].scsiid = aha152x1[2]; 3747 setup[setup_count].reconnect = aha152x1[3]; 3748 setup[setup_count].parity = aha152x1[4]; 3749 setup[setup_count].synchronous = aha152x1[5]; 3750 setup[setup_count].delay = aha152x1[6]; 3751 setup[setup_count].ext_trans = aha152x1[7]; 3752 #if defined(AHA152X_DEBUG) 3753 setup[setup_count].debug = aha152x1[8]; 3754 #endif 3755 } else if(io[1]!=0 || irq[1]!=0) { 3756 if(io[1]!=0) setup[setup_count].io_port = io[1]; 3757 if(irq[1]!=0) setup[setup_count].irq = irq[1]; 3758 3759 setup[setup_count].scsiid = scsiid[1]; 3760 setup[setup_count].reconnect = reconnect[1]; 3761 setup[setup_count].parity = parity[1]; 3762 setup[setup_count].synchronous = sync[1]; 3763 setup[setup_count].delay = delay[1]; 3764 setup[setup_count].ext_trans = exttrans[1]; 3765 #if defined(AHA152X_DEBUG) 3766 setup[setup_count].debug = debug[1]; 3767 #endif 3768 } 3769 if (checksetup(&setup[setup_count])) 3770 setup_count++; 3771 else 3772 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", 3773 setup[setup_count].io_port, 3774 setup[setup_count].irq, 3775 setup[setup_count].scsiid, 3776 setup[setup_count].reconnect, 3777 setup[setup_count].parity, 3778 setup[setup_count].synchronous, 3779 setup[setup_count].delay, 3780 setup[setup_count].ext_trans); 3781 } 3782 #endif 3783 3784 #ifdef __ISAPNP__ 3785 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) { 3786 while ( setup_count<ARRAY_SIZE(setup) && 3787 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) { 3788 if (pnp_device_attach(dev) < 0) 3789 continue; 3790 3791 if (pnp_activate_dev(dev) < 0) { 3792 pnp_device_detach(dev); 3793 continue; 3794 } 3795 3796 if (!pnp_port_valid(dev, 0)) { 3797 pnp_device_detach(dev); 3798 continue; 3799 } 3800 3801 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) { 3802 pnp_device_detach(dev); 3803 continue; 3804 } 3805 3806 setup[setup_count].io_port = pnp_port_start(dev, 0); 3807 setup[setup_count].irq = pnp_irq(dev, 0); 3808 setup[setup_count].scsiid = 7; 3809 setup[setup_count].reconnect = 1; 3810 setup[setup_count].parity = 1; 3811 setup[setup_count].synchronous = 1; 3812 setup[setup_count].delay = DELAY_DEFAULT; 3813 setup[setup_count].ext_trans = 0; 3814 #if defined(AHA152X_DEBUG) 3815 setup[setup_count].debug = DEBUG_DEFAULT; 3816 #endif 3817 #if defined(__ISAPNP__) 3818 pnpdev[setup_count] = dev; 3819 #endif 3820 printk (KERN_INFO 3821 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n", 3822 setup[setup_count].io_port, setup[setup_count].irq); 3823 setup_count++; 3824 } 3825 } 3826 #endif 3827 3828 #if defined(AUTOCONF) 3829 if (setup_count<ARRAY_SIZE(setup)) { 3830 #if !defined(SKIP_BIOSTEST) 3831 ok = 0; 3832 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) { 3833 void __iomem *p = ioremap(addresses[i], 0x4000); 3834 if (!p) 3835 continue; 3836 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++) 3837 ok = check_signature(p + signatures[j].sig_offset, 3838 signatures[j].signature, signatures[j].sig_length); 3839 iounmap(p); 3840 } 3841 if (!ok && setup_count == 0) 3842 return 0; 3843 3844 printk(KERN_INFO "aha152x: BIOS test: passed, "); 3845 #else 3846 printk(KERN_INFO "aha152x: "); 3847 #endif /* !SKIP_BIOSTEST */ 3848 3849 ok = 0; 3850 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) { 3851 if ((setup_count == 1) && (setup[0].io_port == ports[i])) 3852 continue; 3853 3854 if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) { 3855 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]); 3856 continue; 3857 } 3858 3859 if (aha152x_porttest(ports[i])) { 3860 setup[setup_count].tc1550 = 0; 3861 3862 conf.cf_port = 3863 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB); 3864 } else if (tc1550_porttest(ports[i])) { 3865 setup[setup_count].tc1550 = 1; 3866 3867 conf.cf_port = 3868 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB); 3869 } else { 3870 release_region(ports[i], IO_RANGE); 3871 continue; 3872 } 3873 3874 release_region(ports[i], IO_RANGE); 3875 3876 ok++; 3877 setup[setup_count].io_port = ports[i]; 3878 setup[setup_count].irq = IRQ_MIN + conf.cf_irq; 3879 setup[setup_count].scsiid = conf.cf_id; 3880 setup[setup_count].reconnect = conf.cf_tardisc; 3881 setup[setup_count].parity = !conf.cf_parity; 3882 setup[setup_count].synchronous = conf.cf_syncneg; 3883 setup[setup_count].delay = DELAY_DEFAULT; 3884 setup[setup_count].ext_trans = 0; 3885 #if defined(AHA152X_DEBUG) 3886 setup[setup_count].debug = DEBUG_DEFAULT; 3887 #endif 3888 setup_count++; 3889 3890 } 3891 3892 if (ok) 3893 printk("auto configuration: ok, "); 3894 } 3895 #endif 3896 3897 printk("%d controller(s) configured\n", setup_count); 3898 3899 for (i=0; i<setup_count; i++) { 3900 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) { 3901 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]); 3902 3903 if( !shpnt ) { 3904 release_region(setup[i].io_port, IO_RANGE); 3905 #if defined(__ISAPNP__) 3906 } else if( pnpdev[i] ) { 3907 HOSTDATA(shpnt)->pnpdev=pnpdev[i]; 3908 pnpdev[i]=NULL; 3909 #endif 3910 } 3911 } else { 3912 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port); 3913 } 3914 3915 #if defined(__ISAPNP__) 3916 if( pnpdev[i] ) 3917 pnp_device_detach(pnpdev[i]); 3918 #endif 3919 } 3920 3921 return registered_count>0; 3922 } 3923 3924 static void __exit aha152x_exit(void) 3925 { 3926 int i; 3927 3928 for(i=0; i<ARRAY_SIZE(setup); i++) { 3929 aha152x_release(aha152x_host[i]); 3930 aha152x_host[i]=NULL; 3931 } 3932 } 3933 3934 module_init(aha152x_init); 3935 module_exit(aha152x_exit); 3936 3937 #if !defined(MODULE) 3938 static int __init aha152x_setup(char *str) 3939 { 3940 #if defined(AHA152X_DEBUG) 3941 int ints[11]; 3942 #else 3943 int ints[10]; 3944 #endif 3945 get_options(str, ARRAY_SIZE(ints), ints); 3946 3947 if(setup_count>=ARRAY_SIZE(setup)) { 3948 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n"); 3949 return 1; 3950 } 3951 3952 setup[setup_count].conf = str; 3953 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340; 3954 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11; 3955 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7; 3956 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1; 3957 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1; 3958 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1; 3959 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT; 3960 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0; 3961 #if defined(AHA152X_DEBUG) 3962 setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT; 3963 if (ints[0] > 9) { 3964 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>" 3965 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n"); 3966 #else 3967 if (ints[0] > 8) { /*}*/ 3968 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>" 3969 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n"); 3970 #endif 3971 } else { 3972 setup_count++; 3973 return 0; 3974 } 3975 3976 return 1; 3977 } 3978 __setup("aha152x=", aha152x_setup); 3979 #endif 3980 3981 #endif /* !PCMCIA */ 3982