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