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_array(io, int, NULL, 0); 335 MODULE_PARM_DESC(io,"base io address of controller"); 336 337 static int irq[] = {0, 0}; 338 module_param_array(irq, int, 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 Scsi_Cmnd *issue_SC; 426 /* pending commands to issue */ 427 428 Scsi_Cmnd *current_SC; 429 /* current command on the bus */ 430 431 Scsi_Cmnd *disconnected_SC; 432 /* commands that disconnected */ 433 434 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 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(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(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC) 646 { 647 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 Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC) 660 { 661 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 Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun) 672 { 673 Scsi_Cmnd *ptr, *prev; 674 675 for (ptr = *SC, prev = NULL; 676 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun)); 677 prev = ptr, ptr = SCNEXT(ptr)) 678 ; 679 680 if (ptr) { 681 if (prev) 682 SCNEXT(prev) = SCNEXT(ptr); 683 else 684 *SC = SCNEXT(ptr); 685 686 SCNEXT(ptr)=NULL; 687 } 688 689 return ptr; 690 } 691 692 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp) 693 { 694 Scsi_Cmnd *ptr, *prev; 695 696 for (ptr = *SC, prev = NULL; 697 ptr && SCp!=ptr; 698 prev = ptr, ptr = SCNEXT(ptr)) 699 ; 700 701 if (ptr) { 702 if (prev) 703 SCNEXT(prev) = SCNEXT(ptr); 704 else 705 *SC = SCNEXT(ptr); 706 707 SCNEXT(ptr)=NULL; 708 } 709 710 return ptr; 711 } 712 713 static irqreturn_t swintr(int irqno, void *dev_id) 714 { 715 struct Scsi_Host *shpnt = dev_id; 716 717 HOSTDATA(shpnt)->swint++; 718 719 SETPORT(DMACNTRL0, INTEN); 720 return IRQ_HANDLED; 721 } 722 723 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup) 724 { 725 struct Scsi_Host *shpnt; 726 727 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata)); 728 if (!shpnt) { 729 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n"); 730 return NULL; 731 } 732 733 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt)); 734 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list); 735 736 /* need to have host registered before triggering any interrupt */ 737 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list); 738 739 shpnt->io_port = setup->io_port; 740 shpnt->n_io_port = IO_RANGE; 741 shpnt->irq = setup->irq; 742 743 if (!setup->tc1550) { 744 HOSTIOPORT0 = setup->io_port; 745 HOSTIOPORT1 = setup->io_port; 746 } else { 747 HOSTIOPORT0 = setup->io_port+0x10; 748 HOSTIOPORT1 = setup->io_port-0x10; 749 } 750 751 spin_lock_init(&QLOCK); 752 RECONNECT = setup->reconnect; 753 SYNCHRONOUS = setup->synchronous; 754 PARITY = setup->parity; 755 DELAY = setup->delay; 756 EXT_TRANS = setup->ext_trans; 757 758 SETPORT(SCSIID, setup->scsiid << 4); 759 shpnt->this_id = setup->scsiid; 760 761 if (setup->reconnect) 762 shpnt->can_queue = AHA152X_MAXQUEUE; 763 764 /* RESET OUT */ 765 printk("aha152x: resetting bus...\n"); 766 SETPORT(SCSISEQ, SCSIRSTO); 767 mdelay(256); 768 SETPORT(SCSISEQ, 0); 769 mdelay(DELAY); 770 771 reset_ports(shpnt); 772 773 printk(KERN_INFO 774 "aha152x%d%s: " 775 "vital data: rev=%x, " 776 "io=0x%03lx (0x%03lx/0x%03lx), " 777 "irq=%d, " 778 "scsiid=%d, " 779 "reconnect=%s, " 780 "parity=%s, " 781 "synchronous=%s, " 782 "delay=%d, " 783 "extended translation=%s\n", 784 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "", 785 GETPORT(REV) & 0x7, 786 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1, 787 shpnt->irq, 788 shpnt->this_id, 789 RECONNECT ? "enabled" : "disabled", 790 PARITY ? "enabled" : "disabled", 791 SYNCHRONOUS ? "enabled" : "disabled", 792 DELAY, 793 EXT_TRANS ? "enabled" : "disabled"); 794 795 /* not expecting any interrupts */ 796 SETPORT(SIMODE0, 0); 797 SETPORT(SIMODE1, 0); 798 799 if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) { 800 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq); 801 goto out_host_put; 802 } 803 804 HOSTDATA(shpnt)->swint = 0; 805 806 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no); 807 808 mb(); 809 SETPORT(DMACNTRL0, SWINT|INTEN); 810 mdelay(1000); 811 free_irq(shpnt->irq, shpnt); 812 813 if (!HOSTDATA(shpnt)->swint) { 814 if (TESTHI(DMASTAT, INTSTAT)) { 815 printk("lost.\n"); 816 } else { 817 printk("failed.\n"); 818 } 819 820 SETPORT(DMACNTRL0, INTEN); 821 822 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. " 823 "Please verify.\n", shpnt->host_no, shpnt->irq); 824 goto out_host_put; 825 } 826 printk("ok.\n"); 827 828 829 /* clear interrupts */ 830 SETPORT(SSTAT0, 0x7f); 831 SETPORT(SSTAT1, 0xef); 832 833 if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) { 834 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq); 835 goto out_host_put; 836 } 837 838 if( scsi_add_host(shpnt, NULL) ) { 839 free_irq(shpnt->irq, shpnt); 840 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no); 841 goto out_host_put; 842 } 843 844 scsi_scan_host(shpnt); 845 846 return shpnt; 847 848 out_host_put: 849 list_del(&HOSTDATA(shpnt)->host_list); 850 scsi_host_put(shpnt); 851 852 return NULL; 853 } 854 855 void aha152x_release(struct Scsi_Host *shpnt) 856 { 857 if (!shpnt) 858 return; 859 860 scsi_remove_host(shpnt); 861 if (shpnt->irq) 862 free_irq(shpnt->irq, shpnt); 863 864 #if !defined(PCMCIA) 865 if (shpnt->io_port) 866 release_region(shpnt->io_port, IO_RANGE); 867 #endif 868 869 #ifdef __ISAPNP__ 870 if (HOSTDATA(shpnt)->pnpdev) 871 pnp_device_detach(HOSTDATA(shpnt)->pnpdev); 872 #endif 873 874 list_del(&HOSTDATA(shpnt)->host_list); 875 scsi_host_put(shpnt); 876 } 877 878 879 /* 880 * setup controller to generate interrupts depending 881 * on current state (lock has to be acquired) 882 * 883 */ 884 static int setup_expected_interrupts(struct Scsi_Host *shpnt) 885 { 886 if(CURRENT_SC) { 887 CURRENT_SC->SCp.phase |= 1 << 16; 888 889 if(CURRENT_SC->SCp.phase & selecting) { 890 SETPORT(SSTAT1, SELTO); 891 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0)); 892 SETPORT(SIMODE1, ENSELTIMO); 893 } else { 894 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0); 895 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 896 } 897 } else if(STATE==seldi) { 898 SETPORT(SIMODE0, 0); 899 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE); 900 } else { 901 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0); 902 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0)); 903 } 904 905 if(!HOSTDATA(shpnt)->in_intr) 906 SETBITS(DMACNTRL0, INTEN); 907 908 return TESTHI(DMASTAT, INTSTAT); 909 } 910 911 912 /* 913 * Queue a command and setup interrupts for a free bus. 914 */ 915 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete, 916 int phase, void (*done)(Scsi_Cmnd *)) 917 { 918 struct Scsi_Host *shpnt = SCpnt->device->host; 919 unsigned long flags; 920 921 SCpnt->scsi_done = done; 922 SCpnt->SCp.phase = not_issued | phase; 923 SCpnt->SCp.Status = 0x1; /* Ilegal status by SCSI standard */ 924 SCpnt->SCp.Message = 0; 925 SCpnt->SCp.have_data_in = 0; 926 SCpnt->SCp.sent_command = 0; 927 928 if(SCpnt->SCp.phase & (resetting|check_condition)) { 929 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) { 930 scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n"); 931 return FAILED; 932 } 933 } else { 934 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC); 935 if(!SCpnt->host_scribble) { 936 scmd_printk(KERN_ERR, SCpnt, "allocation failed\n"); 937 return FAILED; 938 } 939 } 940 941 SCNEXT(SCpnt) = NULL; 942 SCSEM(SCpnt) = complete; 943 944 /* setup scratch area 945 SCp.ptr : buffer pointer 946 SCp.this_residual : buffer length 947 SCp.buffer : next buffer 948 SCp.buffers_residual : left buffers in list 949 SCp.phase : current state of the command */ 950 951 if ((phase & resetting) || !scsi_sglist(SCpnt)) { 952 SCpnt->SCp.ptr = NULL; 953 SCpnt->SCp.this_residual = 0; 954 scsi_set_resid(SCpnt, 0); 955 SCpnt->SCp.buffer = NULL; 956 SCpnt->SCp.buffers_residual = 0; 957 } else { 958 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt)); 959 SCpnt->SCp.buffer = scsi_sglist(SCpnt); 960 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer); 961 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; 962 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1; 963 } 964 965 DO_LOCK(flags); 966 967 #if defined(AHA152X_STAT) 968 HOSTDATA(shpnt)->total_commands++; 969 #endif 970 971 /* Turn led on, when this is the first command. */ 972 HOSTDATA(shpnt)->commands++; 973 if (HOSTDATA(shpnt)->commands==1) 974 SETPORT(PORTA, 1); 975 976 append_SC(&ISSUE_SC, SCpnt); 977 978 if(!HOSTDATA(shpnt)->in_intr) 979 setup_expected_interrupts(shpnt); 980 981 DO_UNLOCK(flags); 982 983 return 0; 984 } 985 986 /* 987 * queue a command 988 * 989 */ 990 static int aha152x_queue_lck(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) 991 { 992 return aha152x_internal_queue(SCpnt, NULL, 0, done); 993 } 994 995 static DEF_SCSI_QCMD(aha152x_queue) 996 997 998 /* 999 * 1000 */ 1001 static void reset_done(Scsi_Cmnd *SCpnt) 1002 { 1003 if(SCSEM(SCpnt)) { 1004 complete(SCSEM(SCpnt)); 1005 } else { 1006 printk(KERN_ERR "aha152x: reset_done w/o completion\n"); 1007 } 1008 } 1009 1010 /* 1011 * Abort a command 1012 * 1013 */ 1014 static int aha152x_abort(Scsi_Cmnd *SCpnt) 1015 { 1016 struct Scsi_Host *shpnt = SCpnt->device->host; 1017 Scsi_Cmnd *ptr; 1018 unsigned long flags; 1019 1020 DO_LOCK(flags); 1021 1022 ptr=remove_SC(&ISSUE_SC, SCpnt); 1023 1024 if(ptr) { 1025 HOSTDATA(shpnt)->commands--; 1026 if (!HOSTDATA(shpnt)->commands) 1027 SETPORT(PORTA, 0); 1028 DO_UNLOCK(flags); 1029 1030 kfree(SCpnt->host_scribble); 1031 SCpnt->host_scribble=NULL; 1032 1033 return SUCCESS; 1034 } 1035 1036 DO_UNLOCK(flags); 1037 1038 /* 1039 * FIXME: 1040 * for current command: queue ABORT for message out and raise ATN 1041 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection? 1042 * 1043 */ 1044 1045 scmd_printk(KERN_ERR, SCpnt, 1046 "cannot abort running or disconnected command\n"); 1047 1048 return FAILED; 1049 } 1050 1051 /* 1052 * Reset a device 1053 * 1054 */ 1055 static int aha152x_device_reset(Scsi_Cmnd * SCpnt) 1056 { 1057 struct Scsi_Host *shpnt = SCpnt->device->host; 1058 DECLARE_COMPLETION(done); 1059 int ret, issued, disconnected; 1060 unsigned char old_cmd_len = SCpnt->cmd_len; 1061 unsigned long flags; 1062 unsigned long timeleft; 1063 1064 if(CURRENT_SC==SCpnt) { 1065 scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n"); 1066 return FAILED; 1067 } 1068 1069 DO_LOCK(flags); 1070 issued = remove_SC(&ISSUE_SC, SCpnt) == NULL; 1071 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt); 1072 DO_UNLOCK(flags); 1073 1074 SCpnt->cmd_len = 0; 1075 1076 aha152x_internal_queue(SCpnt, &done, resetting, reset_done); 1077 1078 timeleft = wait_for_completion_timeout(&done, 100*HZ); 1079 if (!timeleft) { 1080 /* remove command from issue queue */ 1081 DO_LOCK(flags); 1082 remove_SC(&ISSUE_SC, SCpnt); 1083 DO_UNLOCK(flags); 1084 } 1085 1086 SCpnt->cmd_len = old_cmd_len; 1087 1088 DO_LOCK(flags); 1089 1090 if(SCpnt->SCp.phase & resetted) { 1091 HOSTDATA(shpnt)->commands--; 1092 if (!HOSTDATA(shpnt)->commands) 1093 SETPORT(PORTA, 0); 1094 kfree(SCpnt->host_scribble); 1095 SCpnt->host_scribble=NULL; 1096 1097 ret = SUCCESS; 1098 } else { 1099 /* requeue */ 1100 if(!issued) { 1101 append_SC(&ISSUE_SC, SCpnt); 1102 } else if(disconnected) { 1103 append_SC(&DISCONNECTED_SC, SCpnt); 1104 } 1105 1106 ret = FAILED; 1107 } 1108 1109 DO_UNLOCK(flags); 1110 return ret; 1111 } 1112 1113 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs) 1114 { 1115 Scsi_Cmnd *ptr; 1116 1117 ptr=*SCs; 1118 while(ptr) { 1119 Scsi_Cmnd *next; 1120 1121 if(SCDATA(ptr)) { 1122 next = SCNEXT(ptr); 1123 } else { 1124 scmd_printk(KERN_DEBUG, ptr, 1125 "queue corrupted at %p\n", ptr); 1126 next = NULL; 1127 } 1128 1129 if (!ptr->device->soft_reset) { 1130 remove_SC(SCs, ptr); 1131 HOSTDATA(shpnt)->commands--; 1132 kfree(ptr->host_scribble); 1133 ptr->host_scribble=NULL; 1134 } 1135 1136 ptr = next; 1137 } 1138 } 1139 1140 /* 1141 * Reset the bus 1142 * 1143 */ 1144 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt) 1145 { 1146 unsigned long flags; 1147 1148 DO_LOCK(flags); 1149 1150 free_hard_reset_SCs(shpnt, &ISSUE_SC); 1151 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC); 1152 1153 SETPORT(SCSISEQ, SCSIRSTO); 1154 mdelay(256); 1155 SETPORT(SCSISEQ, 0); 1156 mdelay(DELAY); 1157 1158 setup_expected_interrupts(shpnt); 1159 if(HOSTDATA(shpnt)->commands==0) 1160 SETPORT(PORTA, 0); 1161 1162 DO_UNLOCK(flags); 1163 1164 return SUCCESS; 1165 } 1166 1167 /* 1168 * Reset the bus 1169 * 1170 */ 1171 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt) 1172 { 1173 return aha152x_bus_reset_host(SCpnt->device->host); 1174 } 1175 1176 /* 1177 * Restore default values to the AIC-6260 registers and reset the fifos 1178 * 1179 */ 1180 static void reset_ports(struct Scsi_Host *shpnt) 1181 { 1182 unsigned long flags; 1183 1184 /* disable interrupts */ 1185 SETPORT(DMACNTRL0, RSTFIFO); 1186 1187 SETPORT(SCSISEQ, 0); 1188 1189 SETPORT(SXFRCTL1, 0); 1190 SETPORT(SCSISIG, 0); 1191 SETRATE(0); 1192 1193 /* clear all interrupt conditions */ 1194 SETPORT(SSTAT0, 0x7f); 1195 SETPORT(SSTAT1, 0xef); 1196 1197 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR); 1198 1199 SETPORT(DMACNTRL0, 0); 1200 SETPORT(DMACNTRL1, 0); 1201 1202 SETPORT(BRSTCNTRL, 0xf1); 1203 1204 /* clear SCSI fifos and transfer count */ 1205 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 1206 SETPORT(SXFRCTL0, CH1); 1207 1208 DO_LOCK(flags); 1209 setup_expected_interrupts(shpnt); 1210 DO_UNLOCK(flags); 1211 } 1212 1213 /* 1214 * Reset the host (bus and controller) 1215 * 1216 */ 1217 int aha152x_host_reset_host(struct Scsi_Host *shpnt) 1218 { 1219 aha152x_bus_reset_host(shpnt); 1220 reset_ports(shpnt); 1221 1222 return SUCCESS; 1223 } 1224 1225 /* 1226 * Reset the host (bus and controller) 1227 * 1228 */ 1229 static int aha152x_host_reset(Scsi_Cmnd *SCpnt) 1230 { 1231 return aha152x_host_reset_host(SCpnt->device->host); 1232 } 1233 1234 /* 1235 * Return the "logical geometry" 1236 * 1237 */ 1238 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev, 1239 sector_t capacity, int *info_array) 1240 { 1241 struct Scsi_Host *shpnt = sdev->host; 1242 1243 /* try default translation */ 1244 info_array[0] = 64; 1245 info_array[1] = 32; 1246 info_array[2] = (unsigned long)capacity / (64 * 32); 1247 1248 /* for disks >1GB do some guessing */ 1249 if (info_array[2] >= 1024) { 1250 int info[3]; 1251 1252 /* try to figure out the geometry from the partition table */ 1253 if (scsicam_bios_param(bdev, capacity, info) < 0 || 1254 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) { 1255 if (EXT_TRANS) { 1256 printk(KERN_NOTICE 1257 "aha152x: unable to verify geometry for disk with >1GB.\n" 1258 " using extended translation.\n"); 1259 info_array[0] = 255; 1260 info_array[1] = 63; 1261 info_array[2] = (unsigned long)capacity / (255 * 63); 1262 } else { 1263 printk(KERN_NOTICE 1264 "aha152x: unable to verify geometry for disk with >1GB.\n" 1265 " Using default translation. Please verify yourself.\n" 1266 " Perhaps you need to enable extended translation in the driver.\n" 1267 " See Documentation/scsi/aha152x.txt for details.\n"); 1268 } 1269 } else { 1270 info_array[0] = info[0]; 1271 info_array[1] = info[1]; 1272 info_array[2] = info[2]; 1273 1274 if (info[0] == 255 && !EXT_TRANS) { 1275 printk(KERN_NOTICE 1276 "aha152x: current partition table is using extended translation.\n" 1277 " using it also, although it's not explicitly enabled.\n"); 1278 } 1279 } 1280 } 1281 1282 return 0; 1283 } 1284 1285 /* 1286 * Internal done function 1287 * 1288 */ 1289 static void done(struct Scsi_Host *shpnt, int error) 1290 { 1291 if (CURRENT_SC) { 1292 if(DONE_SC) 1293 scmd_printk(KERN_ERR, CURRENT_SC, 1294 "there's already a completed command %p " 1295 "- will cause abort\n", DONE_SC); 1296 1297 DONE_SC = CURRENT_SC; 1298 CURRENT_SC = NULL; 1299 DONE_SC->result = error; 1300 } else 1301 printk(KERN_ERR "aha152x: done() called outside of command\n"); 1302 } 1303 1304 static struct work_struct aha152x_tq; 1305 1306 /* 1307 * Run service completions on the card with interrupts enabled. 1308 * 1309 */ 1310 static void run(struct work_struct *work) 1311 { 1312 struct aha152x_hostdata *hd; 1313 1314 list_for_each_entry(hd, &aha152x_host_list, host_list) { 1315 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata); 1316 1317 is_complete(shost); 1318 } 1319 } 1320 1321 /* 1322 * Interrupt handler 1323 * 1324 */ 1325 static irqreturn_t intr(int irqno, void *dev_id) 1326 { 1327 struct Scsi_Host *shpnt = dev_id; 1328 unsigned long flags; 1329 unsigned char rev, dmacntrl0; 1330 1331 /* 1332 * Read a couple of registers that are known to not be all 1's. If 1333 * we read all 1's (-1), that means that either: 1334 * 1335 * a. The host adapter chip has gone bad, and we cannot control it, 1336 * OR 1337 * b. The host adapter is a PCMCIA card that has been ejected 1338 * 1339 * In either case, we cannot do anything with the host adapter at 1340 * this point in time. So just ignore the interrupt and return. 1341 * In the latter case, the interrupt might actually be meant for 1342 * someone else sharing this IRQ, and that driver will handle it. 1343 */ 1344 rev = GETPORT(REV); 1345 dmacntrl0 = GETPORT(DMACNTRL0); 1346 if ((rev == 0xFF) && (dmacntrl0 == 0xFF)) 1347 return IRQ_NONE; 1348 1349 if( TESTLO(DMASTAT, INTSTAT) ) 1350 return IRQ_NONE; 1351 1352 /* no more interrupts from the controller, while we're busy. 1353 INTEN is restored by the BH handler */ 1354 CLRBITS(DMACNTRL0, INTEN); 1355 1356 DO_LOCK(flags); 1357 if( HOSTDATA(shpnt)->service==0 ) { 1358 HOSTDATA(shpnt)->service=1; 1359 1360 /* Poke the BH handler */ 1361 INIT_WORK(&aha152x_tq, run); 1362 schedule_work(&aha152x_tq); 1363 } 1364 DO_UNLOCK(flags); 1365 1366 return IRQ_HANDLED; 1367 } 1368 1369 /* 1370 * busfree phase 1371 * - handle completition/disconnection/error of current command 1372 * - start selection for next command (if any) 1373 */ 1374 static void busfree_run(struct Scsi_Host *shpnt) 1375 { 1376 unsigned long flags; 1377 #if defined(AHA152X_STAT) 1378 int action=0; 1379 #endif 1380 1381 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 1382 SETPORT(SXFRCTL0, CH1); 1383 1384 SETPORT(SSTAT1, CLRBUSFREE); 1385 1386 if(CURRENT_SC) { 1387 #if defined(AHA152X_STAT) 1388 action++; 1389 #endif 1390 CURRENT_SC->SCp.phase &= ~syncneg; 1391 1392 if(CURRENT_SC->SCp.phase & completed) { 1393 /* target sent COMMAND COMPLETE */ 1394 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16)); 1395 1396 } else if(CURRENT_SC->SCp.phase & aborted) { 1397 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16)); 1398 1399 } else if(CURRENT_SC->SCp.phase & resetted) { 1400 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16)); 1401 1402 } else if(CURRENT_SC->SCp.phase & disconnected) { 1403 /* target sent DISCONNECT */ 1404 #if defined(AHA152X_STAT) 1405 HOSTDATA(shpnt)->disconnections++; 1406 #endif 1407 append_SC(&DISCONNECTED_SC, CURRENT_SC); 1408 CURRENT_SC->SCp.phase |= 1 << 16; 1409 CURRENT_SC = NULL; 1410 1411 } else { 1412 done(shpnt, DID_ERROR << 16); 1413 } 1414 #if defined(AHA152X_STAT) 1415 } else { 1416 HOSTDATA(shpnt)->busfree_without_old_command++; 1417 #endif 1418 } 1419 1420 DO_LOCK(flags); 1421 1422 if(DONE_SC) { 1423 #if defined(AHA152X_STAT) 1424 action++; 1425 #endif 1426 1427 if(DONE_SC->SCp.phase & check_condition) { 1428 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC; 1429 struct aha152x_scdata *sc = SCDATA(cmd); 1430 1431 scsi_eh_restore_cmnd(cmd, &sc->ses); 1432 1433 cmd->SCp.Status = SAM_STAT_CHECK_CONDITION; 1434 1435 HOSTDATA(shpnt)->commands--; 1436 if (!HOSTDATA(shpnt)->commands) 1437 SETPORT(PORTA, 0); /* turn led off */ 1438 } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) { 1439 #if defined(AHA152X_STAT) 1440 HOSTDATA(shpnt)->busfree_with_check_condition++; 1441 #endif 1442 1443 if(!(DONE_SC->SCp.phase & not_issued)) { 1444 struct aha152x_scdata *sc; 1445 Scsi_Cmnd *ptr = DONE_SC; 1446 DONE_SC=NULL; 1447 1448 sc = SCDATA(ptr); 1449 /* It was allocated in aha152x_internal_queue? */ 1450 BUG_ON(!sc); 1451 scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0); 1452 1453 DO_UNLOCK(flags); 1454 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done); 1455 DO_LOCK(flags); 1456 } 1457 } 1458 1459 if(DONE_SC && DONE_SC->scsi_done) { 1460 Scsi_Cmnd *ptr = DONE_SC; 1461 DONE_SC=NULL; 1462 1463 /* turn led off, when no commands are in the driver */ 1464 HOSTDATA(shpnt)->commands--; 1465 if (!HOSTDATA(shpnt)->commands) 1466 SETPORT(PORTA, 0); /* turn led off */ 1467 1468 if(ptr->scsi_done != reset_done) { 1469 kfree(ptr->host_scribble); 1470 ptr->host_scribble=NULL; 1471 } 1472 1473 DO_UNLOCK(flags); 1474 ptr->scsi_done(ptr); 1475 DO_LOCK(flags); 1476 } 1477 1478 DONE_SC=NULL; 1479 #if defined(AHA152X_STAT) 1480 } else { 1481 HOSTDATA(shpnt)->busfree_without_done_command++; 1482 #endif 1483 } 1484 1485 if(ISSUE_SC) 1486 CURRENT_SC = remove_first_SC(&ISSUE_SC); 1487 1488 DO_UNLOCK(flags); 1489 1490 if(CURRENT_SC) { 1491 #if defined(AHA152X_STAT) 1492 action++; 1493 #endif 1494 CURRENT_SC->SCp.phase |= selecting; 1495 1496 /* clear selection timeout */ 1497 SETPORT(SSTAT1, SELTO); 1498 1499 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id); 1500 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER); 1501 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0)); 1502 } else { 1503 #if defined(AHA152X_STAT) 1504 HOSTDATA(shpnt)->busfree_without_new_command++; 1505 #endif 1506 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0); 1507 } 1508 1509 #if defined(AHA152X_STAT) 1510 if(!action) 1511 HOSTDATA(shpnt)->busfree_without_any_action++; 1512 #endif 1513 } 1514 1515 /* 1516 * Selection done (OUT) 1517 * - queue IDENTIFY message and SDTR to selected target for message out 1518 * (ATN asserted automagically via ENAUTOATNO in busfree()) 1519 */ 1520 static void seldo_run(struct Scsi_Host *shpnt) 1521 { 1522 SETPORT(SCSISIG, 0); 1523 SETPORT(SSTAT1, CLRBUSFREE); 1524 SETPORT(SSTAT1, CLRPHASECHG); 1525 1526 CURRENT_SC->SCp.phase &= ~(selecting|not_issued); 1527 1528 SETPORT(SCSISEQ, 0); 1529 1530 if (TESTLO(SSTAT0, SELDO)) { 1531 scmd_printk(KERN_ERR, CURRENT_SC, 1532 "aha152x: passing bus free condition\n"); 1533 done(shpnt, DID_NO_CONNECT << 16); 1534 return; 1535 } 1536 1537 SETPORT(SSTAT0, CLRSELDO); 1538 1539 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun)); 1540 1541 if (CURRENT_SC->SCp.phase & aborting) { 1542 ADDMSGO(ABORT); 1543 } else if (CURRENT_SC->SCp.phase & resetting) { 1544 ADDMSGO(BUS_DEVICE_RESET); 1545 } else if (SYNCNEG==0 && SYNCHRONOUS) { 1546 CURRENT_SC->SCp.phase |= syncneg; 1547 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8); 1548 SYNCNEG=1; /* negotiation in progress */ 1549 } 1550 1551 SETRATE(SYNCRATE); 1552 } 1553 1554 /* 1555 * Selection timeout 1556 * - return command to mid-level with failure cause 1557 * 1558 */ 1559 static void selto_run(struct Scsi_Host *shpnt) 1560 { 1561 SETPORT(SCSISEQ, 0); 1562 SETPORT(SSTAT1, CLRSELTIMO); 1563 1564 if (!CURRENT_SC) 1565 return; 1566 1567 CURRENT_SC->SCp.phase &= ~selecting; 1568 1569 if (CURRENT_SC->SCp.phase & aborted) 1570 done(shpnt, DID_ABORT << 16); 1571 else if (TESTLO(SSTAT0, SELINGO)) 1572 done(shpnt, DID_BUS_BUSY << 16); 1573 else 1574 /* ARBITRATION won, but SELECTION failed */ 1575 done(shpnt, DID_NO_CONNECT << 16); 1576 } 1577 1578 /* 1579 * Selection in done 1580 * - put current command back to issue queue 1581 * (reconnection of a disconnected nexus instead 1582 * of successful selection out) 1583 * 1584 */ 1585 static void seldi_run(struct Scsi_Host *shpnt) 1586 { 1587 int selid; 1588 int target; 1589 unsigned long flags; 1590 1591 SETPORT(SCSISIG, 0); 1592 SETPORT(SSTAT0, CLRSELDI); 1593 SETPORT(SSTAT1, CLRBUSFREE); 1594 SETPORT(SSTAT1, CLRPHASECHG); 1595 1596 if(CURRENT_SC) { 1597 if(!(CURRENT_SC->SCp.phase & not_issued)) 1598 scmd_printk(KERN_ERR, CURRENT_SC, 1599 "command should not have been issued yet\n"); 1600 1601 DO_LOCK(flags); 1602 append_SC(&ISSUE_SC, CURRENT_SC); 1603 DO_UNLOCK(flags); 1604 1605 CURRENT_SC = NULL; 1606 } 1607 1608 if (!DISCONNECTED_SC) 1609 return; 1610 1611 RECONN_TARGET=-1; 1612 1613 selid = GETPORT(SELID) & ~(1 << shpnt->this_id); 1614 1615 if (selid==0) { 1616 shost_printk(KERN_INFO, shpnt, 1617 "target id unknown (%02x)\n", selid); 1618 return; 1619 } 1620 1621 for(target=7; !(selid & (1 << target)); target--) 1622 ; 1623 1624 if(selid & ~(1 << target)) { 1625 shost_printk(KERN_INFO, shpnt, 1626 "multiple targets reconnected (%02x)\n", selid); 1627 } 1628 1629 1630 SETPORT(SCSIID, (shpnt->this_id << OID_) | target); 1631 SETPORT(SCSISEQ, 0); 1632 1633 SETRATE(HOSTDATA(shpnt)->syncrate[target]); 1634 1635 RECONN_TARGET=target; 1636 } 1637 1638 /* 1639 * message in phase 1640 * - handle initial message after reconnection to identify 1641 * reconnecting nexus 1642 * - queue command on DISCONNECTED_SC on DISCONNECT message 1643 * - set completed flag on COMMAND COMPLETE 1644 * (other completition code moved to busfree_run) 1645 * - handle response to SDTR 1646 * - clear synchronous transfer agreements on BUS RESET 1647 * 1648 * FIXME: what about SAVE POINTERS, RESTORE POINTERS? 1649 * 1650 */ 1651 static void msgi_run(struct Scsi_Host *shpnt) 1652 { 1653 for(;;) { 1654 int sstat1 = GETPORT(SSTAT1); 1655 1656 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT)) 1657 return; 1658 1659 if (TESTLO(SSTAT0, SPIORDY)) 1660 return; 1661 1662 ADDMSGI(GETPORT(SCSIDAT)); 1663 1664 if(!CURRENT_SC) { 1665 if(LASTSTATE!=seldi) { 1666 shost_printk(KERN_ERR, shpnt, 1667 "message in w/o current command" 1668 " not after reselection\n"); 1669 } 1670 1671 /* 1672 * Handle reselection 1673 */ 1674 if(!(MSGI(0) & IDENTIFY_BASE)) { 1675 shost_printk(KERN_ERR, shpnt, 1676 "target didn't identify after reselection\n"); 1677 continue; 1678 } 1679 1680 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f); 1681 1682 if (!CURRENT_SC) { 1683 show_queues(shpnt); 1684 shost_printk(KERN_ERR, shpnt, 1685 "no disconnected command" 1686 " for target %d/%d\n", 1687 RECONN_TARGET, MSGI(0) & 0x3f); 1688 continue; 1689 } 1690 1691 CURRENT_SC->SCp.Message = MSGI(0); 1692 CURRENT_SC->SCp.phase &= ~disconnected; 1693 1694 MSGILEN=0; 1695 1696 /* next message if any */ 1697 continue; 1698 } 1699 1700 CURRENT_SC->SCp.Message = MSGI(0); 1701 1702 switch (MSGI(0)) { 1703 case DISCONNECT: 1704 if (!RECONNECT) 1705 scmd_printk(KERN_WARNING, CURRENT_SC, 1706 "target was not allowed to disconnect\n"); 1707 1708 CURRENT_SC->SCp.phase |= disconnected; 1709 break; 1710 1711 case COMMAND_COMPLETE: 1712 CURRENT_SC->SCp.phase |= completed; 1713 break; 1714 1715 case MESSAGE_REJECT: 1716 if (SYNCNEG==1) { 1717 scmd_printk(KERN_INFO, CURRENT_SC, 1718 "Synchronous Data Transfer Request" 1719 " was rejected\n"); 1720 SYNCNEG=2; /* negotiation completed */ 1721 } else 1722 scmd_printk(KERN_INFO, CURRENT_SC, 1723 "inbound message (MESSAGE REJECT)\n"); 1724 break; 1725 1726 case SAVE_POINTERS: 1727 break; 1728 1729 case RESTORE_POINTERS: 1730 break; 1731 1732 case EXTENDED_MESSAGE: 1733 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) { 1734 /* not yet completed */ 1735 continue; 1736 } 1737 1738 switch (MSGI(2)) { 1739 case EXTENDED_SDTR: 1740 { 1741 long ticks; 1742 1743 if (MSGI(1) != 3) { 1744 scmd_printk(KERN_ERR, CURRENT_SC, 1745 "SDTR message length!=3\n"); 1746 break; 1747 } 1748 1749 if (!HOSTDATA(shpnt)->synchronous) 1750 break; 1751 1752 printk(INFO_LEAD, CMDINFO(CURRENT_SC)); 1753 spi_print_msg(&MSGI(0)); 1754 printk("\n"); 1755 1756 ticks = (MSGI(3) * 4 + 49) / 50; 1757 1758 if (syncneg) { 1759 /* negotiation in progress */ 1760 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) { 1761 ADDMSGO(MESSAGE_REJECT); 1762 scmd_printk(KERN_INFO, 1763 CURRENT_SC, 1764 "received Synchronous Data Transfer Request invalid - rejected\n"); 1765 break; 1766 } 1767 1768 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4); 1769 } else if (ticks <= 9 && MSGI(4) >= 1) { 1770 ADDMSGO(EXTENDED_MESSAGE); 1771 ADDMSGO(3); 1772 ADDMSGO(EXTENDED_SDTR); 1773 if (ticks < 4) { 1774 ticks = 4; 1775 ADDMSGO(50); 1776 } else 1777 ADDMSGO(MSGI(3)); 1778 1779 if (MSGI(4) > 8) 1780 MSGI(4) = 8; 1781 1782 ADDMSGO(MSGI(4)); 1783 1784 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4); 1785 } else { 1786 /* requested SDTR is too slow, do it asynchronously */ 1787 scmd_printk(KERN_INFO, 1788 CURRENT_SC, 1789 "Synchronous Data Transfer Request too slow - Rejecting\n"); 1790 ADDMSGO(MESSAGE_REJECT); 1791 } 1792 1793 /* negotiation completed */ 1794 SYNCNEG=2; 1795 SETRATE(SYNCRATE); 1796 } 1797 break; 1798 1799 case BUS_DEVICE_RESET: 1800 { 1801 int i; 1802 1803 for(i=0; i<8; i++) { 1804 HOSTDATA(shpnt)->syncrate[i]=0; 1805 HOSTDATA(shpnt)->syncneg[i]=0; 1806 } 1807 1808 } 1809 break; 1810 1811 case EXTENDED_MODIFY_DATA_POINTER: 1812 case EXTENDED_EXTENDED_IDENTIFY: 1813 case EXTENDED_WDTR: 1814 default: 1815 ADDMSGO(MESSAGE_REJECT); 1816 break; 1817 } 1818 break; 1819 } 1820 1821 MSGILEN=0; 1822 } 1823 } 1824 1825 static void msgi_end(struct Scsi_Host *shpnt) 1826 { 1827 if(MSGILEN>0) 1828 scmd_printk(KERN_WARNING, CURRENT_SC, 1829 "target left before message completed (%d)\n", 1830 MSGILEN); 1831 1832 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) 1833 SETPORT(SCSISIG, P_MSGI | SIG_ATNO); 1834 } 1835 1836 /* 1837 * message out phase 1838 * 1839 */ 1840 static void msgo_init(struct Scsi_Host *shpnt) 1841 { 1842 if(MSGOLEN==0) { 1843 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) { 1844 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun)); 1845 } else { 1846 scmd_printk(KERN_INFO, CURRENT_SC, 1847 "unexpected MESSAGE OUT phase; rejecting\n"); 1848 ADDMSGO(MESSAGE_REJECT); 1849 } 1850 } 1851 1852 } 1853 1854 /* 1855 * message out phase 1856 * 1857 */ 1858 static void msgo_run(struct Scsi_Host *shpnt) 1859 { 1860 while(MSGO_I<MSGOLEN) { 1861 if (TESTLO(SSTAT0, SPIORDY)) 1862 return; 1863 1864 if (MSGO_I==MSGOLEN-1) { 1865 /* Leave MESSAGE OUT after transfer */ 1866 SETPORT(SSTAT1, CLRATNO); 1867 } 1868 1869 1870 if (MSGO(MSGO_I) & IDENTIFY_BASE) 1871 CURRENT_SC->SCp.phase |= identified; 1872 1873 if (MSGO(MSGO_I)==ABORT) 1874 CURRENT_SC->SCp.phase |= aborted; 1875 1876 if (MSGO(MSGO_I)==BUS_DEVICE_RESET) 1877 CURRENT_SC->SCp.phase |= resetted; 1878 1879 SETPORT(SCSIDAT, MSGO(MSGO_I++)); 1880 } 1881 } 1882 1883 static void msgo_end(struct Scsi_Host *shpnt) 1884 { 1885 if(MSGO_I<MSGOLEN) { 1886 scmd_printk(KERN_ERR, CURRENT_SC, 1887 "message sent incompletely (%d/%d)\n", 1888 MSGO_I, MSGOLEN); 1889 if(SYNCNEG==1) { 1890 scmd_printk(KERN_INFO, CURRENT_SC, 1891 "Synchronous Data Transfer Request was rejected\n"); 1892 SYNCNEG=2; 1893 } 1894 } 1895 1896 MSGO_I = 0; 1897 MSGOLEN = 0; 1898 } 1899 1900 /* 1901 * command phase 1902 * 1903 */ 1904 static void cmd_init(struct Scsi_Host *shpnt) 1905 { 1906 if (CURRENT_SC->SCp.sent_command) { 1907 scmd_printk(KERN_ERR, CURRENT_SC, 1908 "command already sent\n"); 1909 done(shpnt, DID_ERROR << 16); 1910 return; 1911 } 1912 1913 CMD_I=0; 1914 } 1915 1916 /* 1917 * command phase 1918 * 1919 */ 1920 static void cmd_run(struct Scsi_Host *shpnt) 1921 { 1922 while(CMD_I<CURRENT_SC->cmd_len) { 1923 if (TESTLO(SSTAT0, SPIORDY)) 1924 return; 1925 1926 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]); 1927 } 1928 } 1929 1930 static void cmd_end(struct Scsi_Host *shpnt) 1931 { 1932 if(CMD_I<CURRENT_SC->cmd_len) 1933 scmd_printk(KERN_ERR, CURRENT_SC, 1934 "command sent incompletely (%d/%d)\n", 1935 CMD_I, CURRENT_SC->cmd_len); 1936 else 1937 CURRENT_SC->SCp.sent_command++; 1938 } 1939 1940 /* 1941 * status phase 1942 * 1943 */ 1944 static void status_run(struct Scsi_Host *shpnt) 1945 { 1946 if (TESTLO(SSTAT0, SPIORDY)) 1947 return; 1948 1949 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT); 1950 1951 } 1952 1953 /* 1954 * data in phase 1955 * 1956 */ 1957 static void datai_init(struct Scsi_Host *shpnt) 1958 { 1959 SETPORT(DMACNTRL0, RSTFIFO); 1960 SETPORT(DMACNTRL0, RSTFIFO|ENDMA); 1961 1962 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 1963 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN); 1964 1965 SETPORT(SIMODE0, 0); 1966 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE); 1967 1968 DATA_LEN=0; 1969 } 1970 1971 static void datai_run(struct Scsi_Host *shpnt) 1972 { 1973 unsigned long the_time; 1974 int fifodata, data_count; 1975 1976 /* 1977 * loop while the phase persists or the fifos are not empty 1978 * 1979 */ 1980 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) { 1981 /* FIXME: maybe this should be done by setting up 1982 * STCNT to trigger ENSWRAP interrupt, instead of 1983 * polling for DFIFOFULL 1984 */ 1985 the_time=jiffies + 100*HZ; 1986 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time)) 1987 barrier(); 1988 1989 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) { 1990 scmd_printk(KERN_ERR, CURRENT_SC, "datai timeout\n"); 1991 break; 1992 } 1993 1994 if(TESTHI(DMASTAT, DFIFOFULL)) { 1995 fifodata = 128; 1996 } else { 1997 the_time=jiffies + 100*HZ; 1998 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time)) 1999 barrier(); 2000 2001 if(TESTLO(SSTAT2, SEMPTY)) { 2002 scmd_printk(KERN_ERR, CURRENT_SC, 2003 "datai sempty timeout"); 2004 break; 2005 } 2006 2007 fifodata = GETPORT(FIFOSTAT); 2008 } 2009 2010 if(CURRENT_SC->SCp.this_residual>0) { 2011 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) { 2012 data_count = fifodata > CURRENT_SC->SCp.this_residual ? 2013 CURRENT_SC->SCp.this_residual : 2014 fifodata; 2015 fifodata -= data_count; 2016 2017 if (data_count & 1) { 2018 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2019 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT); 2020 CURRENT_SC->SCp.this_residual--; 2021 DATA_LEN++; 2022 SETPORT(DMACNTRL0, ENDMA); 2023 } 2024 2025 if (data_count > 1) { 2026 data_count >>= 1; 2027 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count); 2028 CURRENT_SC->SCp.ptr += 2 * data_count; 2029 CURRENT_SC->SCp.this_residual -= 2 * data_count; 2030 DATA_LEN += 2 * data_count; 2031 } 2032 2033 if (CURRENT_SC->SCp.this_residual == 0 && 2034 CURRENT_SC->SCp.buffers_residual > 0) { 2035 /* advance to next buffer */ 2036 CURRENT_SC->SCp.buffers_residual--; 2037 CURRENT_SC->SCp.buffer++; 2038 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer); 2039 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length; 2040 } 2041 } 2042 } else if (fifodata > 0) { 2043 scmd_printk(KERN_ERR, CURRENT_SC, 2044 "no buffers left for %d(%d) bytes" 2045 " (data overrun!?)\n", 2046 fifodata, GETPORT(FIFOSTAT)); 2047 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2048 while(fifodata>0) { 2049 int data; 2050 data=GETPORT(DATAPORT); 2051 fifodata--; 2052 DATA_LEN++; 2053 } 2054 SETPORT(DMACNTRL0, ENDMA|_8BIT); 2055 } 2056 } 2057 2058 if(TESTLO(DMASTAT, INTSTAT) || 2059 TESTLO(DMASTAT, DFIFOEMP) || 2060 TESTLO(SSTAT2, SEMPTY) || 2061 GETPORT(FIFOSTAT)>0) { 2062 /* 2063 * something went wrong, if there's something left in the fifos 2064 * or the phase didn't change 2065 */ 2066 scmd_printk(KERN_ERR, CURRENT_SC, 2067 "fifos should be empty and phase should have changed\n"); 2068 } 2069 2070 if(DATA_LEN!=GETSTCNT()) { 2071 scmd_printk(KERN_ERR, CURRENT_SC, 2072 "manual transfer count differs from automatic " 2073 "(count=%d;stcnt=%d;diff=%d;fifostat=%d)", 2074 DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, 2075 GETPORT(FIFOSTAT)); 2076 mdelay(10000); 2077 } 2078 } 2079 2080 static void datai_end(struct Scsi_Host *shpnt) 2081 { 2082 CMD_INC_RESID(CURRENT_SC, -GETSTCNT()); 2083 2084 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 2085 SETPORT(DMACNTRL0, 0); 2086 } 2087 2088 /* 2089 * data out phase 2090 * 2091 */ 2092 static void datao_init(struct Scsi_Host *shpnt) 2093 { 2094 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO); 2095 SETPORT(DMACNTRL0, WRITE_READ | ENDMA); 2096 2097 SETPORT(SXFRCTL0, CH1|CLRSTCNT); 2098 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN); 2099 2100 SETPORT(SIMODE0, 0); 2101 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE ); 2102 2103 DATA_LEN = scsi_get_resid(CURRENT_SC); 2104 } 2105 2106 static void datao_run(struct Scsi_Host *shpnt) 2107 { 2108 unsigned long the_time; 2109 int data_count; 2110 2111 /* until phase changes or all data sent */ 2112 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) { 2113 data_count = 128; 2114 if(data_count > CURRENT_SC->SCp.this_residual) 2115 data_count=CURRENT_SC->SCp.this_residual; 2116 2117 if(TESTLO(DMASTAT, DFIFOEMP)) { 2118 scmd_printk(KERN_ERR, CURRENT_SC, 2119 "datao fifo not empty (%d)", 2120 GETPORT(FIFOSTAT)); 2121 break; 2122 } 2123 2124 if(data_count & 1) { 2125 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT); 2126 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++); 2127 CURRENT_SC->SCp.this_residual--; 2128 CMD_INC_RESID(CURRENT_SC, -1); 2129 SETPORT(DMACNTRL0,WRITE_READ|ENDMA); 2130 } 2131 2132 if(data_count > 1) { 2133 data_count >>= 1; 2134 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count); 2135 CURRENT_SC->SCp.ptr += 2 * data_count; 2136 CURRENT_SC->SCp.this_residual -= 2 * data_count; 2137 CMD_INC_RESID(CURRENT_SC, -2 * data_count); 2138 } 2139 2140 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) { 2141 /* advance to next buffer */ 2142 CURRENT_SC->SCp.buffers_residual--; 2143 CURRENT_SC->SCp.buffer++; 2144 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer); 2145 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length; 2146 } 2147 2148 the_time=jiffies + 100*HZ; 2149 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time)) 2150 barrier(); 2151 2152 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) { 2153 scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n"); 2154 break; 2155 } 2156 } 2157 } 2158 2159 static void datao_end(struct Scsi_Host *shpnt) 2160 { 2161 if(TESTLO(DMASTAT, DFIFOEMP)) { 2162 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) - 2163 GETSTCNT(); 2164 2165 CMD_INC_RESID(CURRENT_SC, data_count); 2166 2167 data_count -= CURRENT_SC->SCp.ptr - 2168 SG_ADDRESS(CURRENT_SC->SCp.buffer); 2169 while(data_count>0) { 2170 CURRENT_SC->SCp.buffer--; 2171 CURRENT_SC->SCp.buffers_residual++; 2172 data_count -= CURRENT_SC->SCp.buffer->length; 2173 } 2174 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) - 2175 data_count; 2176 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + 2177 data_count; 2178 } 2179 2180 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT); 2181 SETPORT(SXFRCTL0, CH1); 2182 2183 SETPORT(DMACNTRL0, 0); 2184 } 2185 2186 /* 2187 * figure out what state we're in 2188 * 2189 */ 2190 static int update_state(struct Scsi_Host *shpnt) 2191 { 2192 int dataphase=0; 2193 unsigned int stat0 = GETPORT(SSTAT0); 2194 unsigned int stat1 = GETPORT(SSTAT1); 2195 2196 PREVSTATE = STATE; 2197 STATE=unknown; 2198 2199 if(stat1 & SCSIRSTI) { 2200 STATE=rsti; 2201 SETPORT(SCSISEQ,0); 2202 SETPORT(SSTAT1,SCSIRSTI); 2203 } else if (stat0 & SELDI && PREVSTATE == busfree) { 2204 STATE=seldi; 2205 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) { 2206 STATE=seldo; 2207 } else if(stat1 & SELTO) { 2208 STATE=selto; 2209 } else if(stat1 & BUSFREE) { 2210 STATE=busfree; 2211 SETPORT(SSTAT1,BUSFREE); 2212 } else if(stat1 & SCSIPERR) { 2213 STATE=parerr; 2214 SETPORT(SSTAT1,SCSIPERR); 2215 } else if(stat1 & REQINIT) { 2216 switch(GETPORT(SCSISIG) & P_MASK) { 2217 case P_MSGI: STATE=msgi; break; 2218 case P_MSGO: STATE=msgo; break; 2219 case P_DATAO: STATE=datao; break; 2220 case P_DATAI: STATE=datai; break; 2221 case P_STATUS: STATE=status; break; 2222 case P_CMD: STATE=cmd; break; 2223 } 2224 dataphase=1; 2225 } 2226 2227 if((stat0 & SELDI) && STATE!=seldi && !dataphase) { 2228 scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?"); 2229 } 2230 2231 if(STATE!=PREVSTATE) { 2232 LASTSTATE=PREVSTATE; 2233 } 2234 2235 return dataphase; 2236 } 2237 2238 /* 2239 * handle parity error 2240 * 2241 * FIXME: in which phase? 2242 * 2243 */ 2244 static void parerr_run(struct Scsi_Host *shpnt) 2245 { 2246 scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n"); 2247 done(shpnt, DID_PARITY << 16); 2248 } 2249 2250 /* 2251 * handle reset in 2252 * 2253 */ 2254 static void rsti_run(struct Scsi_Host *shpnt) 2255 { 2256 Scsi_Cmnd *ptr; 2257 2258 shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n"); 2259 2260 ptr=DISCONNECTED_SC; 2261 while(ptr) { 2262 Scsi_Cmnd *next = SCNEXT(ptr); 2263 2264 if (!ptr->device->soft_reset) { 2265 remove_SC(&DISCONNECTED_SC, ptr); 2266 2267 kfree(ptr->host_scribble); 2268 ptr->host_scribble=NULL; 2269 2270 ptr->result = DID_RESET << 16; 2271 ptr->scsi_done(ptr); 2272 } 2273 2274 ptr = next; 2275 } 2276 2277 if(CURRENT_SC && !CURRENT_SC->device->soft_reset) 2278 done(shpnt, DID_RESET << 16 ); 2279 } 2280 2281 2282 /* 2283 * bottom-half handler 2284 * 2285 */ 2286 static void is_complete(struct Scsi_Host *shpnt) 2287 { 2288 int dataphase; 2289 unsigned long flags; 2290 int pending; 2291 2292 if(!shpnt) 2293 return; 2294 2295 DO_LOCK(flags); 2296 2297 if( HOSTDATA(shpnt)->service==0 ) { 2298 DO_UNLOCK(flags); 2299 return; 2300 } 2301 2302 HOSTDATA(shpnt)->service = 0; 2303 2304 if(HOSTDATA(shpnt)->in_intr) { 2305 DO_UNLOCK(flags); 2306 /* aha152x_error never returns.. */ 2307 aha152x_error(shpnt, "bottom-half already running!?"); 2308 } 2309 HOSTDATA(shpnt)->in_intr++; 2310 2311 /* 2312 * loop while there are interrupt conditions pending 2313 * 2314 */ 2315 do { 2316 unsigned long start = jiffies; 2317 DO_UNLOCK(flags); 2318 2319 dataphase=update_state(shpnt); 2320 2321 /* 2322 * end previous state 2323 * 2324 */ 2325 if(PREVSTATE!=STATE && states[PREVSTATE].end) 2326 states[PREVSTATE].end(shpnt); 2327 2328 /* 2329 * disable SPIO mode if previous phase used it 2330 * and this one doesn't 2331 * 2332 */ 2333 if(states[PREVSTATE].spio && !states[STATE].spio) { 2334 SETPORT(SXFRCTL0, CH1); 2335 SETPORT(DMACNTRL0, 0); 2336 if(CURRENT_SC) 2337 CURRENT_SC->SCp.phase &= ~spiordy; 2338 } 2339 2340 /* 2341 * accept current dataphase phase 2342 * 2343 */ 2344 if(dataphase) { 2345 SETPORT(SSTAT0, REQINIT); 2346 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK); 2347 SETPORT(SSTAT1, PHASECHG); 2348 } 2349 2350 /* 2351 * enable SPIO mode if previous didn't use it 2352 * and this one does 2353 * 2354 */ 2355 if(!states[PREVSTATE].spio && states[STATE].spio) { 2356 SETPORT(DMACNTRL0, 0); 2357 SETPORT(SXFRCTL0, CH1|SPIOEN); 2358 if(CURRENT_SC) 2359 CURRENT_SC->SCp.phase |= spiordy; 2360 } 2361 2362 /* 2363 * initialize for new state 2364 * 2365 */ 2366 if(PREVSTATE!=STATE && states[STATE].init) 2367 states[STATE].init(shpnt); 2368 2369 /* 2370 * handle current state 2371 * 2372 */ 2373 if(states[STATE].run) 2374 states[STATE].run(shpnt); 2375 else 2376 scmd_printk(KERN_ERR, CURRENT_SC, 2377 "unexpected state (%x)\n", STATE); 2378 2379 /* 2380 * setup controller to interrupt on 2381 * the next expected condition and 2382 * loop if it's already there 2383 * 2384 */ 2385 DO_LOCK(flags); 2386 pending=setup_expected_interrupts(shpnt); 2387 #if defined(AHA152X_STAT) 2388 HOSTDATA(shpnt)->count[STATE]++; 2389 if(PREVSTATE!=STATE) 2390 HOSTDATA(shpnt)->count_trans[STATE]++; 2391 HOSTDATA(shpnt)->time[STATE] += jiffies-start; 2392 #endif 2393 2394 } while(pending); 2395 2396 /* 2397 * enable interrupts and leave bottom-half 2398 * 2399 */ 2400 HOSTDATA(shpnt)->in_intr--; 2401 SETBITS(DMACNTRL0, INTEN); 2402 DO_UNLOCK(flags); 2403 } 2404 2405 2406 /* 2407 * Dump the current driver status and panic 2408 */ 2409 static void aha152x_error(struct Scsi_Host *shpnt, char *msg) 2410 { 2411 shost_printk(KERN_EMERG, shpnt, "%s\n", msg); 2412 show_queues(shpnt); 2413 panic("aha152x panic\n"); 2414 } 2415 2416 /* 2417 * display enabled interrupts 2418 */ 2419 static void disp_enintr(struct Scsi_Host *shpnt) 2420 { 2421 int s0, s1; 2422 2423 s0 = GETPORT(SIMODE0); 2424 s1 = GETPORT(SIMODE1); 2425 2426 shost_printk(KERN_DEBUG, shpnt, 2427 "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n", 2428 (s0 & ENSELDO) ? "ENSELDO " : "", 2429 (s0 & ENSELDI) ? "ENSELDI " : "", 2430 (s0 & ENSELINGO) ? "ENSELINGO " : "", 2431 (s0 & ENSWRAP) ? "ENSWRAP " : "", 2432 (s0 & ENSDONE) ? "ENSDONE " : "", 2433 (s0 & ENSPIORDY) ? "ENSPIORDY " : "", 2434 (s0 & ENDMADONE) ? "ENDMADONE " : "", 2435 (s1 & ENSELTIMO) ? "ENSELTIMO " : "", 2436 (s1 & ENATNTARG) ? "ENATNTARG " : "", 2437 (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "", 2438 (s1 & ENBUSFREE) ? "ENBUSFREE " : "", 2439 (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "", 2440 (s1 & ENPHASECHG) ? "ENPHASECHG " : "", 2441 (s1 & ENREQINIT) ? "ENREQINIT " : ""); 2442 } 2443 2444 /* 2445 * Show the command data of a command 2446 */ 2447 static void show_command(Scsi_Cmnd *ptr) 2448 { 2449 scsi_print_command(ptr); 2450 scmd_printk(KERN_DEBUG, ptr, 2451 "request_bufflen=%d; resid=%d; " 2452 "phase |%s%s%s%s%s%s%s%s%s; next=0x%p", 2453 scsi_bufflen(ptr), scsi_get_resid(ptr), 2454 (ptr->SCp.phase & not_issued) ? "not issued|" : "", 2455 (ptr->SCp.phase & selecting) ? "selecting|" : "", 2456 (ptr->SCp.phase & identified) ? "identified|" : "", 2457 (ptr->SCp.phase & disconnected) ? "disconnected|" : "", 2458 (ptr->SCp.phase & completed) ? "completed|" : "", 2459 (ptr->SCp.phase & spiordy) ? "spiordy|" : "", 2460 (ptr->SCp.phase & syncneg) ? "syncneg|" : "", 2461 (ptr->SCp.phase & aborted) ? "aborted|" : "", 2462 (ptr->SCp.phase & resetted) ? "resetted|" : "", 2463 (SCDATA(ptr)) ? SCNEXT(ptr) : NULL); 2464 } 2465 2466 /* 2467 * Dump the queued data 2468 */ 2469 static void show_queues(struct Scsi_Host *shpnt) 2470 { 2471 Scsi_Cmnd *ptr; 2472 unsigned long flags; 2473 2474 DO_LOCK(flags); 2475 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n"); 2476 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr)) 2477 show_command(ptr); 2478 DO_UNLOCK(flags); 2479 2480 printk(KERN_DEBUG "current_SC:\n"); 2481 if (CURRENT_SC) 2482 show_command(CURRENT_SC); 2483 else 2484 printk(KERN_DEBUG "none\n"); 2485 2486 printk(KERN_DEBUG "disconnected_SC:\n"); 2487 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL) 2488 show_command(ptr); 2489 2490 disp_enintr(shpnt); 2491 } 2492 2493 static void get_command(struct seq_file *m, Scsi_Cmnd * ptr) 2494 { 2495 int i; 2496 2497 seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ", 2498 ptr, ptr->device->id, (u8)ptr->device->lun); 2499 2500 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++) 2501 seq_printf(m, "0x%02x ", ptr->cmnd[i]); 2502 2503 seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |", 2504 scsi_get_resid(ptr), ptr->SCp.this_residual, 2505 ptr->SCp.buffers_residual); 2506 2507 if (ptr->SCp.phase & not_issued) 2508 seq_puts(m, "not issued|"); 2509 if (ptr->SCp.phase & selecting) 2510 seq_puts(m, "selecting|"); 2511 if (ptr->SCp.phase & disconnected) 2512 seq_puts(m, "disconnected|"); 2513 if (ptr->SCp.phase & aborted) 2514 seq_puts(m, "aborted|"); 2515 if (ptr->SCp.phase & identified) 2516 seq_puts(m, "identified|"); 2517 if (ptr->SCp.phase & completed) 2518 seq_puts(m, "completed|"); 2519 if (ptr->SCp.phase & spiordy) 2520 seq_puts(m, "spiordy|"); 2521 if (ptr->SCp.phase & syncneg) 2522 seq_puts(m, "syncneg|"); 2523 seq_printf(m, "; next=0x%p\n", SCNEXT(ptr)); 2524 } 2525 2526 static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt) 2527 { 2528 int s; 2529 2530 seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name); 2531 2532 s = GETPORT(SCSISEQ); 2533 seq_puts(m, "SCSISEQ( "); 2534 if (s & TEMODEO) 2535 seq_puts(m, "TARGET MODE "); 2536 if (s & ENSELO) 2537 seq_puts(m, "SELO "); 2538 if (s & ENSELI) 2539 seq_puts(m, "SELI "); 2540 if (s & ENRESELI) 2541 seq_puts(m, "RESELI "); 2542 if (s & ENAUTOATNO) 2543 seq_puts(m, "AUTOATNO "); 2544 if (s & ENAUTOATNI) 2545 seq_puts(m, "AUTOATNI "); 2546 if (s & ENAUTOATNP) 2547 seq_puts(m, "AUTOATNP "); 2548 if (s & SCSIRSTO) 2549 seq_puts(m, "SCSIRSTO "); 2550 seq_puts(m, ");"); 2551 2552 seq_puts(m, " SCSISIG("); 2553 s = GETPORT(SCSISIG); 2554 switch (s & P_MASK) { 2555 case P_DATAO: 2556 seq_puts(m, "DATA OUT"); 2557 break; 2558 case P_DATAI: 2559 seq_puts(m, "DATA IN"); 2560 break; 2561 case P_CMD: 2562 seq_puts(m, "COMMAND"); 2563 break; 2564 case P_STATUS: 2565 seq_puts(m, "STATUS"); 2566 break; 2567 case P_MSGO: 2568 seq_puts(m, "MESSAGE OUT"); 2569 break; 2570 case P_MSGI: 2571 seq_puts(m, "MESSAGE IN"); 2572 break; 2573 default: 2574 seq_puts(m, "*invalid*"); 2575 break; 2576 } 2577 2578 seq_puts(m, "); "); 2579 2580 seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo"); 2581 2582 seq_puts(m, "SSTAT( "); 2583 s = GETPORT(SSTAT0); 2584 if (s & TARGET) 2585 seq_puts(m, "TARGET "); 2586 if (s & SELDO) 2587 seq_puts(m, "SELDO "); 2588 if (s & SELDI) 2589 seq_puts(m, "SELDI "); 2590 if (s & SELINGO) 2591 seq_puts(m, "SELINGO "); 2592 if (s & SWRAP) 2593 seq_puts(m, "SWRAP "); 2594 if (s & SDONE) 2595 seq_puts(m, "SDONE "); 2596 if (s & SPIORDY) 2597 seq_puts(m, "SPIORDY "); 2598 if (s & DMADONE) 2599 seq_puts(m, "DMADONE "); 2600 2601 s = GETPORT(SSTAT1); 2602 if (s & SELTO) 2603 seq_puts(m, "SELTO "); 2604 if (s & ATNTARG) 2605 seq_puts(m, "ATNTARG "); 2606 if (s & SCSIRSTI) 2607 seq_puts(m, "SCSIRSTI "); 2608 if (s & PHASEMIS) 2609 seq_puts(m, "PHASEMIS "); 2610 if (s & BUSFREE) 2611 seq_puts(m, "BUSFREE "); 2612 if (s & SCSIPERR) 2613 seq_puts(m, "SCSIPERR "); 2614 if (s & PHASECHG) 2615 seq_puts(m, "PHASECHG "); 2616 if (s & REQINIT) 2617 seq_puts(m, "REQINIT "); 2618 seq_puts(m, "); "); 2619 2620 2621 seq_puts(m, "SSTAT( "); 2622 2623 s = GETPORT(SSTAT0) & GETPORT(SIMODE0); 2624 2625 if (s & TARGET) 2626 seq_puts(m, "TARGET "); 2627 if (s & SELDO) 2628 seq_puts(m, "SELDO "); 2629 if (s & SELDI) 2630 seq_puts(m, "SELDI "); 2631 if (s & SELINGO) 2632 seq_puts(m, "SELINGO "); 2633 if (s & SWRAP) 2634 seq_puts(m, "SWRAP "); 2635 if (s & SDONE) 2636 seq_puts(m, "SDONE "); 2637 if (s & SPIORDY) 2638 seq_puts(m, "SPIORDY "); 2639 if (s & DMADONE) 2640 seq_puts(m, "DMADONE "); 2641 2642 s = GETPORT(SSTAT1) & GETPORT(SIMODE1); 2643 2644 if (s & SELTO) 2645 seq_puts(m, "SELTO "); 2646 if (s & ATNTARG) 2647 seq_puts(m, "ATNTARG "); 2648 if (s & SCSIRSTI) 2649 seq_puts(m, "SCSIRSTI "); 2650 if (s & PHASEMIS) 2651 seq_puts(m, "PHASEMIS "); 2652 if (s & BUSFREE) 2653 seq_puts(m, "BUSFREE "); 2654 if (s & SCSIPERR) 2655 seq_puts(m, "SCSIPERR "); 2656 if (s & PHASECHG) 2657 seq_puts(m, "PHASECHG "); 2658 if (s & REQINIT) 2659 seq_puts(m, "REQINIT "); 2660 seq_puts(m, "); "); 2661 2662 seq_puts(m, "SXFRCTL0( "); 2663 2664 s = GETPORT(SXFRCTL0); 2665 if (s & SCSIEN) 2666 seq_puts(m, "SCSIEN "); 2667 if (s & DMAEN) 2668 seq_puts(m, "DMAEN "); 2669 if (s & CH1) 2670 seq_puts(m, "CH1 "); 2671 if (s & CLRSTCNT) 2672 seq_puts(m, "CLRSTCNT "); 2673 if (s & SPIOEN) 2674 seq_puts(m, "SPIOEN "); 2675 if (s & CLRCH1) 2676 seq_puts(m, "CLRCH1 "); 2677 seq_puts(m, "); "); 2678 2679 seq_puts(m, "SIGNAL( "); 2680 2681 s = GETPORT(SCSISIG); 2682 if (s & SIG_ATNI) 2683 seq_puts(m, "ATNI "); 2684 if (s & SIG_SELI) 2685 seq_puts(m, "SELI "); 2686 if (s & SIG_BSYI) 2687 seq_puts(m, "BSYI "); 2688 if (s & SIG_REQI) 2689 seq_puts(m, "REQI "); 2690 if (s & SIG_ACKI) 2691 seq_puts(m, "ACKI "); 2692 seq_puts(m, "); "); 2693 2694 seq_printf(m, "SELID(%02x), ", GETPORT(SELID)); 2695 2696 seq_printf(m, "STCNT(%d), ", GETSTCNT()); 2697 2698 seq_puts(m, "SSTAT2( "); 2699 2700 s = GETPORT(SSTAT2); 2701 if (s & SOFFSET) 2702 seq_puts(m, "SOFFSET "); 2703 if (s & SEMPTY) 2704 seq_puts(m, "SEMPTY "); 2705 if (s & SFULL) 2706 seq_puts(m, "SFULL "); 2707 seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT)); 2708 2709 s = GETPORT(SSTAT3); 2710 seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f); 2711 2712 seq_puts(m, "SSTAT4( "); 2713 s = GETPORT(SSTAT4); 2714 if (s & SYNCERR) 2715 seq_puts(m, "SYNCERR "); 2716 if (s & FWERR) 2717 seq_puts(m, "FWERR "); 2718 if (s & FRERR) 2719 seq_puts(m, "FRERR "); 2720 seq_puts(m, "); "); 2721 2722 seq_puts(m, "DMACNTRL0( "); 2723 s = GETPORT(DMACNTRL0); 2724 seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT"); 2725 seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO"); 2726 seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ"); 2727 if (s & ENDMA) 2728 seq_puts(m, "ENDMA "); 2729 if (s & INTEN) 2730 seq_puts(m, "INTEN "); 2731 if (s & RSTFIFO) 2732 seq_puts(m, "RSTFIFO "); 2733 if (s & SWINT) 2734 seq_puts(m, "SWINT "); 2735 seq_puts(m, "); "); 2736 2737 seq_puts(m, "DMASTAT( "); 2738 s = GETPORT(DMASTAT); 2739 if (s & ATDONE) 2740 seq_puts(m, "ATDONE "); 2741 if (s & WORDRDY) 2742 seq_puts(m, "WORDRDY "); 2743 if (s & DFIFOFULL) 2744 seq_puts(m, "DFIFOFULL "); 2745 if (s & DFIFOEMP) 2746 seq_puts(m, "DFIFOEMP "); 2747 seq_puts(m, ")\n"); 2748 2749 seq_puts(m, "enabled interrupts( "); 2750 2751 s = GETPORT(SIMODE0); 2752 if (s & ENSELDO) 2753 seq_puts(m, "ENSELDO "); 2754 if (s & ENSELDI) 2755 seq_puts(m, "ENSELDI "); 2756 if (s & ENSELINGO) 2757 seq_puts(m, "ENSELINGO "); 2758 if (s & ENSWRAP) 2759 seq_puts(m, "ENSWRAP "); 2760 if (s & ENSDONE) 2761 seq_puts(m, "ENSDONE "); 2762 if (s & ENSPIORDY) 2763 seq_puts(m, "ENSPIORDY "); 2764 if (s & ENDMADONE) 2765 seq_puts(m, "ENDMADONE "); 2766 2767 s = GETPORT(SIMODE1); 2768 if (s & ENSELTIMO) 2769 seq_puts(m, "ENSELTIMO "); 2770 if (s & ENATNTARG) 2771 seq_puts(m, "ENATNTARG "); 2772 if (s & ENPHASEMIS) 2773 seq_puts(m, "ENPHASEMIS "); 2774 if (s & ENBUSFREE) 2775 seq_puts(m, "ENBUSFREE "); 2776 if (s & ENSCSIPERR) 2777 seq_puts(m, "ENSCSIPERR "); 2778 if (s & ENPHASECHG) 2779 seq_puts(m, "ENPHASECHG "); 2780 if (s & ENREQINIT) 2781 seq_puts(m, "ENREQINIT "); 2782 seq_puts(m, ")\n"); 2783 } 2784 2785 static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length) 2786 { 2787 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0) 2788 return -EINVAL; 2789 2790 #if defined(AHA152X_STAT) 2791 if(length>13 && strncmp("reset", buffer+8, 5)==0) { 2792 int i; 2793 2794 HOSTDATA(shpnt)->total_commands=0; 2795 HOSTDATA(shpnt)->disconnections=0; 2796 HOSTDATA(shpnt)->busfree_without_any_action=0; 2797 HOSTDATA(shpnt)->busfree_without_old_command=0; 2798 HOSTDATA(shpnt)->busfree_without_new_command=0; 2799 HOSTDATA(shpnt)->busfree_without_done_command=0; 2800 HOSTDATA(shpnt)->busfree_with_check_condition=0; 2801 for (i = idle; i<maxstate; i++) { 2802 HOSTDATA(shpnt)->count[i]=0; 2803 HOSTDATA(shpnt)->count_trans[i]=0; 2804 HOSTDATA(shpnt)->time[i]=0; 2805 } 2806 2807 shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n"); 2808 2809 } else 2810 #endif 2811 { 2812 return -EINVAL; 2813 } 2814 2815 2816 return length; 2817 } 2818 2819 static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt) 2820 { 2821 int i; 2822 Scsi_Cmnd *ptr; 2823 unsigned long flags; 2824 2825 seq_puts(m, AHA152X_REVID "\n"); 2826 2827 seq_printf(m, "ioports 0x%04lx to 0x%04lx\n", 2828 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1); 2829 seq_printf(m, "interrupt 0x%02x\n", shpnt->irq); 2830 seq_printf(m, "disconnection/reconnection %s\n", 2831 RECONNECT ? "enabled" : "disabled"); 2832 seq_printf(m, "parity checking %s\n", 2833 PARITY ? "enabled" : "disabled"); 2834 seq_printf(m, "synchronous transfers %s\n", 2835 SYNCHRONOUS ? "enabled" : "disabled"); 2836 seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands); 2837 2838 if(SYNCHRONOUS) { 2839 seq_puts(m, "synchronously operating targets (tick=50 ns):\n"); 2840 for (i = 0; i < 8; i++) 2841 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f) 2842 seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n", 2843 i, 2844 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2), 2845 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50, 2846 HOSTDATA(shpnt)->syncrate[i] & 0x0f); 2847 } 2848 seq_puts(m, "\nqueue status:\n"); 2849 DO_LOCK(flags); 2850 if (ISSUE_SC) { 2851 seq_puts(m, "not yet issued commands:\n"); 2852 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr)) 2853 get_command(m, ptr); 2854 } else 2855 seq_puts(m, "no not yet issued commands\n"); 2856 DO_UNLOCK(flags); 2857 2858 if (CURRENT_SC) { 2859 seq_puts(m, "current command:\n"); 2860 get_command(m, CURRENT_SC); 2861 } else 2862 seq_puts(m, "no current command\n"); 2863 2864 if (DISCONNECTED_SC) { 2865 seq_puts(m, "disconnected commands:\n"); 2866 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr)) 2867 get_command(m, ptr); 2868 } else 2869 seq_puts(m, "no disconnected commands\n"); 2870 2871 get_ports(m, shpnt); 2872 2873 #if defined(AHA152X_STAT) 2874 seq_printf(m, "statistics:\n" 2875 "total commands: %d\n" 2876 "disconnections: %d\n" 2877 "busfree with check condition: %d\n" 2878 "busfree without old command: %d\n" 2879 "busfree without new command: %d\n" 2880 "busfree without done command: %d\n" 2881 "busfree without any action: %d\n" 2882 "state " 2883 "transitions " 2884 "count " 2885 "time\n", 2886 HOSTDATA(shpnt)->total_commands, 2887 HOSTDATA(shpnt)->disconnections, 2888 HOSTDATA(shpnt)->busfree_with_check_condition, 2889 HOSTDATA(shpnt)->busfree_without_old_command, 2890 HOSTDATA(shpnt)->busfree_without_new_command, 2891 HOSTDATA(shpnt)->busfree_without_done_command, 2892 HOSTDATA(shpnt)->busfree_without_any_action); 2893 for(i=0; i<maxstate; i++) { 2894 seq_printf(m, "%-10s %-12d %-12d %-12ld\n", 2895 states[i].name, 2896 HOSTDATA(shpnt)->count_trans[i], 2897 HOSTDATA(shpnt)->count[i], 2898 HOSTDATA(shpnt)->time[i]); 2899 } 2900 #endif 2901 return 0; 2902 } 2903 2904 static int aha152x_adjust_queue(struct scsi_device *device) 2905 { 2906 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH); 2907 return 0; 2908 } 2909 2910 static struct scsi_host_template aha152x_driver_template = { 2911 .module = THIS_MODULE, 2912 .name = AHA152X_REVID, 2913 .proc_name = "aha152x", 2914 .show_info = aha152x_show_info, 2915 .write_info = aha152x_set_info, 2916 .queuecommand = aha152x_queue, 2917 .eh_abort_handler = aha152x_abort, 2918 .eh_device_reset_handler = aha152x_device_reset, 2919 .eh_bus_reset_handler = aha152x_bus_reset, 2920 .eh_host_reset_handler = aha152x_host_reset, 2921 .bios_param = aha152x_biosparam, 2922 .can_queue = 1, 2923 .this_id = 7, 2924 .sg_tablesize = SG_ALL, 2925 .cmd_per_lun = 1, 2926 .use_clustering = DISABLE_CLUSTERING, 2927 .slave_alloc = aha152x_adjust_queue, 2928 }; 2929 2930 #if !defined(PCMCIA) 2931 static int setup_count; 2932 static struct aha152x_setup setup[2]; 2933 2934 /* possible i/o addresses for the AIC-6260; default first */ 2935 static unsigned short ports[] = { 0x340, 0x140 }; 2936 2937 #if !defined(SKIP_BIOSTEST) 2938 /* possible locations for the Adaptec BIOS; defaults first */ 2939 static unsigned int addresses[] = 2940 { 2941 0xdc000, /* default first */ 2942 0xc8000, 2943 0xcc000, 2944 0xd0000, 2945 0xd4000, 2946 0xd8000, 2947 0xe0000, 2948 0xeb800, /* VTech Platinum SMP */ 2949 0xf0000, 2950 }; 2951 2952 /* signatures for various AIC-6[23]60 based controllers. 2953 The point in detecting signatures is to avoid useless and maybe 2954 harmful probes on ports. I'm not sure that all listed boards pass 2955 auto-configuration. For those which fail the BIOS signature is 2956 obsolete, because user intervention to supply the configuration is 2957 needed anyway. May be an information whether or not the BIOS supports 2958 extended translation could be also useful here. */ 2959 static struct signature { 2960 unsigned char *signature; 2961 int sig_offset; 2962 int sig_length; 2963 } signatures[] = 2964 { 2965 { "Adaptec AHA-1520 BIOS", 0x102e, 21 }, 2966 /* Adaptec 152x */ 2967 { "Adaptec AHA-1520B", 0x000b, 17 }, 2968 /* Adaptec 152x rev B */ 2969 { "Adaptec AHA-1520B", 0x0026, 17 }, 2970 /* Iomega Jaz Jet ISA (AIC6370Q) */ 2971 { "Adaptec ASW-B626 BIOS", 0x1029, 21 }, 2972 /* on-board controller */ 2973 { "Adaptec BIOS: ASW-B626", 0x000f, 22 }, 2974 /* on-board controller */ 2975 { "Adaptec ASW-B626 S2", 0x2e6c, 19 }, 2976 /* on-board controller */ 2977 { "Adaptec BIOS:AIC-6360", 0x000c, 21 }, 2978 /* on-board controller */ 2979 { "ScsiPro SP-360 BIOS", 0x2873, 19 }, 2980 /* ScsiPro-Controller */ 2981 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 }, 2982 /* Gigabyte Local-Bus-SCSI */ 2983 { "Adaptec BIOS:AVA-282X", 0x000c, 21 }, 2984 /* Adaptec 282x */ 2985 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 }, 2986 /* IBM Thinkpad Dock II */ 2987 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 }, 2988 /* IBM Thinkpad Dock II SCSI */ 2989 { "DTC3520A Host Adapter BIOS", 0x318a, 26 }, 2990 /* DTC 3520A ISA SCSI */ 2991 }; 2992 #endif /* !SKIP_BIOSTEST */ 2993 2994 /* 2995 * Test, if port_base is valid. 2996 * 2997 */ 2998 static int aha152x_porttest(int io_port) 2999 { 3000 int i; 3001 3002 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */ 3003 for (i = 0; i < 16; i++) 3004 SETPORT(io_port + O_STACK, i); 3005 3006 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */ 3007 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++) 3008 ; 3009 3010 return (i == 16); 3011 } 3012 3013 static int tc1550_porttest(int io_port) 3014 { 3015 int i; 3016 3017 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */ 3018 for (i = 0; i < 16; i++) 3019 SETPORT(io_port + O_STACK, i); 3020 3021 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */ 3022 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++) 3023 ; 3024 3025 return (i == 16); 3026 } 3027 3028 3029 static int checksetup(struct aha152x_setup *setup) 3030 { 3031 int i; 3032 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++) 3033 ; 3034 3035 if (i == ARRAY_SIZE(ports)) 3036 return 0; 3037 3038 if (!request_region(setup->io_port, IO_RANGE, "aha152x")) { 3039 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port); 3040 return 0; 3041 } 3042 3043 if( aha152x_porttest(setup->io_port) ) { 3044 setup->tc1550=0; 3045 } else if( tc1550_porttest(setup->io_port) ) { 3046 setup->tc1550=1; 3047 } else { 3048 release_region(setup->io_port, IO_RANGE); 3049 return 0; 3050 } 3051 3052 release_region(setup->io_port, IO_RANGE); 3053 3054 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX)) 3055 return 0; 3056 3057 if ((setup->scsiid < 0) || (setup->scsiid > 7)) 3058 return 0; 3059 3060 if ((setup->reconnect < 0) || (setup->reconnect > 1)) 3061 return 0; 3062 3063 if ((setup->parity < 0) || (setup->parity > 1)) 3064 return 0; 3065 3066 if ((setup->synchronous < 0) || (setup->synchronous > 1)) 3067 return 0; 3068 3069 if ((setup->ext_trans < 0) || (setup->ext_trans > 1)) 3070 return 0; 3071 3072 3073 return 1; 3074 } 3075 3076 3077 static int __init aha152x_init(void) 3078 { 3079 int i, j, ok; 3080 #if defined(AUTOCONF) 3081 aha152x_config conf; 3082 #endif 3083 #ifdef __ISAPNP__ 3084 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL}; 3085 #endif 3086 3087 if ( setup_count ) { 3088 printk(KERN_INFO "aha152x: processing commandline: "); 3089 3090 for (i = 0; i<setup_count; i++) { 3091 if (!checksetup(&setup[i])) { 3092 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf); 3093 printk(KERN_ERR "aha152x: invalid line\n"); 3094 } 3095 } 3096 printk("ok\n"); 3097 } 3098 3099 #if defined(SETUP0) 3100 if (setup_count < ARRAY_SIZE(setup)) { 3101 struct aha152x_setup override = SETUP0; 3102 3103 if (setup_count == 0 || (override.io_port != setup[0].io_port)) { 3104 if (!checksetup(&override)) { 3105 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n", 3106 override.io_port, 3107 override.irq, 3108 override.scsiid, 3109 override.reconnect, 3110 override.parity, 3111 override.synchronous, 3112 override.delay, 3113 override.ext_trans); 3114 } else 3115 setup[setup_count++] = override; 3116 } 3117 } 3118 #endif 3119 3120 #if defined(SETUP1) 3121 if (setup_count < ARRAY_SIZE(setup)) { 3122 struct aha152x_setup override = SETUP1; 3123 3124 if (setup_count == 0 || (override.io_port != setup[0].io_port)) { 3125 if (!checksetup(&override)) { 3126 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n", 3127 override.io_port, 3128 override.irq, 3129 override.scsiid, 3130 override.reconnect, 3131 override.parity, 3132 override.synchronous, 3133 override.delay, 3134 override.ext_trans); 3135 } else 3136 setup[setup_count++] = override; 3137 } 3138 } 3139 #endif 3140 3141 #if defined(MODULE) 3142 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) { 3143 if(aha152x[0]!=0) { 3144 setup[setup_count].conf = ""; 3145 setup[setup_count].io_port = aha152x[0]; 3146 setup[setup_count].irq = aha152x[1]; 3147 setup[setup_count].scsiid = aha152x[2]; 3148 setup[setup_count].reconnect = aha152x[3]; 3149 setup[setup_count].parity = aha152x[4]; 3150 setup[setup_count].synchronous = aha152x[5]; 3151 setup[setup_count].delay = aha152x[6]; 3152 setup[setup_count].ext_trans = aha152x[7]; 3153 } else if (io[0] != 0 || irq[0] != 0) { 3154 if(io[0]!=0) setup[setup_count].io_port = io[0]; 3155 if(irq[0]!=0) setup[setup_count].irq = irq[0]; 3156 3157 setup[setup_count].scsiid = scsiid[0]; 3158 setup[setup_count].reconnect = reconnect[0]; 3159 setup[setup_count].parity = parity[0]; 3160 setup[setup_count].synchronous = sync[0]; 3161 setup[setup_count].delay = delay[0]; 3162 setup[setup_count].ext_trans = exttrans[0]; 3163 } 3164 3165 if (checksetup(&setup[setup_count])) 3166 setup_count++; 3167 else 3168 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", 3169 setup[setup_count].io_port, 3170 setup[setup_count].irq, 3171 setup[setup_count].scsiid, 3172 setup[setup_count].reconnect, 3173 setup[setup_count].parity, 3174 setup[setup_count].synchronous, 3175 setup[setup_count].delay, 3176 setup[setup_count].ext_trans); 3177 } 3178 3179 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) { 3180 if(aha152x1[0]!=0) { 3181 setup[setup_count].conf = ""; 3182 setup[setup_count].io_port = aha152x1[0]; 3183 setup[setup_count].irq = aha152x1[1]; 3184 setup[setup_count].scsiid = aha152x1[2]; 3185 setup[setup_count].reconnect = aha152x1[3]; 3186 setup[setup_count].parity = aha152x1[4]; 3187 setup[setup_count].synchronous = aha152x1[5]; 3188 setup[setup_count].delay = aha152x1[6]; 3189 setup[setup_count].ext_trans = aha152x1[7]; 3190 } else if (io[1] != 0 || irq[1] != 0) { 3191 if(io[1]!=0) setup[setup_count].io_port = io[1]; 3192 if(irq[1]!=0) setup[setup_count].irq = irq[1]; 3193 3194 setup[setup_count].scsiid = scsiid[1]; 3195 setup[setup_count].reconnect = reconnect[1]; 3196 setup[setup_count].parity = parity[1]; 3197 setup[setup_count].synchronous = sync[1]; 3198 setup[setup_count].delay = delay[1]; 3199 setup[setup_count].ext_trans = exttrans[1]; 3200 } 3201 if (checksetup(&setup[setup_count])) 3202 setup_count++; 3203 else 3204 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", 3205 setup[setup_count].io_port, 3206 setup[setup_count].irq, 3207 setup[setup_count].scsiid, 3208 setup[setup_count].reconnect, 3209 setup[setup_count].parity, 3210 setup[setup_count].synchronous, 3211 setup[setup_count].delay, 3212 setup[setup_count].ext_trans); 3213 } 3214 #endif 3215 3216 #ifdef __ISAPNP__ 3217 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) { 3218 while ( setup_count<ARRAY_SIZE(setup) && 3219 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) { 3220 if (pnp_device_attach(dev) < 0) 3221 continue; 3222 3223 if (pnp_activate_dev(dev) < 0) { 3224 pnp_device_detach(dev); 3225 continue; 3226 } 3227 3228 if (!pnp_port_valid(dev, 0)) { 3229 pnp_device_detach(dev); 3230 continue; 3231 } 3232 3233 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) { 3234 pnp_device_detach(dev); 3235 continue; 3236 } 3237 3238 setup[setup_count].io_port = pnp_port_start(dev, 0); 3239 setup[setup_count].irq = pnp_irq(dev, 0); 3240 setup[setup_count].scsiid = 7; 3241 setup[setup_count].reconnect = 1; 3242 setup[setup_count].parity = 1; 3243 setup[setup_count].synchronous = 1; 3244 setup[setup_count].delay = DELAY_DEFAULT; 3245 setup[setup_count].ext_trans = 0; 3246 #if defined(__ISAPNP__) 3247 pnpdev[setup_count] = dev; 3248 #endif 3249 printk (KERN_INFO 3250 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n", 3251 setup[setup_count].io_port, setup[setup_count].irq); 3252 setup_count++; 3253 } 3254 } 3255 #endif 3256 3257 #if defined(AUTOCONF) 3258 if (setup_count<ARRAY_SIZE(setup)) { 3259 #if !defined(SKIP_BIOSTEST) 3260 ok = 0; 3261 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) { 3262 void __iomem *p = ioremap(addresses[i], 0x4000); 3263 if (!p) 3264 continue; 3265 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++) 3266 ok = check_signature(p + signatures[j].sig_offset, 3267 signatures[j].signature, signatures[j].sig_length); 3268 iounmap(p); 3269 } 3270 if (!ok && setup_count == 0) 3271 return -ENODEV; 3272 3273 printk(KERN_INFO "aha152x: BIOS test: passed, "); 3274 #else 3275 printk(KERN_INFO "aha152x: "); 3276 #endif /* !SKIP_BIOSTEST */ 3277 3278 ok = 0; 3279 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) { 3280 if ((setup_count == 1) && (setup[0].io_port == ports[i])) 3281 continue; 3282 3283 if (!request_region(ports[i], IO_RANGE, "aha152x")) { 3284 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]); 3285 continue; 3286 } 3287 3288 if (aha152x_porttest(ports[i])) { 3289 setup[setup_count].tc1550 = 0; 3290 3291 conf.cf_port = 3292 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB); 3293 } else if (tc1550_porttest(ports[i])) { 3294 setup[setup_count].tc1550 = 1; 3295 3296 conf.cf_port = 3297 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB); 3298 } else { 3299 release_region(ports[i], IO_RANGE); 3300 continue; 3301 } 3302 3303 release_region(ports[i], IO_RANGE); 3304 3305 ok++; 3306 setup[setup_count].io_port = ports[i]; 3307 setup[setup_count].irq = IRQ_MIN + conf.cf_irq; 3308 setup[setup_count].scsiid = conf.cf_id; 3309 setup[setup_count].reconnect = conf.cf_tardisc; 3310 setup[setup_count].parity = !conf.cf_parity; 3311 setup[setup_count].synchronous = conf.cf_syncneg; 3312 setup[setup_count].delay = DELAY_DEFAULT; 3313 setup[setup_count].ext_trans = 0; 3314 setup_count++; 3315 3316 } 3317 3318 if (ok) 3319 printk("auto configuration: ok, "); 3320 } 3321 #endif 3322 3323 printk("%d controller(s) configured\n", setup_count); 3324 3325 for (i=0; i<setup_count; i++) { 3326 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) { 3327 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]); 3328 3329 if( !shpnt ) { 3330 release_region(setup[i].io_port, IO_RANGE); 3331 #if defined(__ISAPNP__) 3332 } else if( pnpdev[i] ) { 3333 HOSTDATA(shpnt)->pnpdev=pnpdev[i]; 3334 pnpdev[i]=NULL; 3335 #endif 3336 } 3337 } else { 3338 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port); 3339 } 3340 3341 #if defined(__ISAPNP__) 3342 if( pnpdev[i] ) 3343 pnp_device_detach(pnpdev[i]); 3344 #endif 3345 } 3346 3347 return 0; 3348 } 3349 3350 static void __exit aha152x_exit(void) 3351 { 3352 struct aha152x_hostdata *hd, *tmp; 3353 3354 list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) { 3355 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata); 3356 3357 aha152x_release(shost); 3358 } 3359 } 3360 3361 module_init(aha152x_init); 3362 module_exit(aha152x_exit); 3363 3364 #if !defined(MODULE) 3365 static int __init aha152x_setup(char *str) 3366 { 3367 int ints[10]; 3368 3369 get_options(str, ARRAY_SIZE(ints), ints); 3370 3371 if(setup_count>=ARRAY_SIZE(setup)) { 3372 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n"); 3373 return 1; 3374 } 3375 3376 setup[setup_count].conf = str; 3377 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340; 3378 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11; 3379 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7; 3380 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1; 3381 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1; 3382 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1; 3383 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT; 3384 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0; 3385 if (ints[0] > 8) { /*}*/ 3386 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>" 3387 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n"); 3388 } else { 3389 setup_count++; 3390 return 0; 3391 } 3392 3393 return 1; 3394 } 3395 __setup("aha152x=", aha152x_setup); 3396 #endif 3397 3398 #endif /* !PCMCIA */ 3399