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