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