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