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