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