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