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