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