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