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