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