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