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