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