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