1 /* aha152x.c -- Adaptec AHA-152x driver
2 * Author: Jürgen E. Fischer, fischer@norbit.de
3 * Copyright 1993-2004 Jürgen E. Fischer
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2, or (at your option) any
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
16 * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
19 * Revision 2.7 2004/01/24 11:42:59 fischer
20 * - gather code that is not used by PCMCIA at the end
21 * - move request_region for !PCMCIA case to detection
22 * - migration to new scsi host api (remove legacy code)
23 * - free host scribble before scsi_done
24 * - fix error handling
25 * - one isapnp device added to id_table
27 * Revision 2.6 2003/10/30 20:52:47 fischer
28 * - interfaces changes for kernel 2.6
29 * - aha152x_probe_one introduced for pcmcia stub
30 * - fixed pnpdev handling
31 * - instead of allocation a new one, reuse command for request sense after check condition and reset
32 * - fixes race in is_complete
34 * Revision 2.5 2002/04/14 11:24:53 fischer
39 * Revision 2.4 2000/12/16 12:53:56 fischer
40 * - allow REQUEST SENSE to be queued
41 * - handle shared PCI interrupts
43 * Revision 2.3 2000/11/04 16:40:26 fischer
44 * - handle data overruns
45 * - extend timeout for data phases
47 * Revision 2.2 2000/08/08 19:54:53 fischer
50 * Revision 2.1 2000/05/17 16:23:17 fischer
52 * - fix for data out w/o scatter gather
54 * Revision 2.0 1999/12/25 15:07:32 fischer
55 * - interrupt routine completly reworked
56 * - basic support for new eh code
58 * Revision 1.21 1999/11/10 23:46:36 fischer
59 * - default to synchronous operation
60 * - synchronous negotiation fixed
61 * - added timeout to loops
62 * - debugging output can be controlled through procfs
64 * Revision 1.20 1999/11/07 18:37:31 fischer
65 * - synchronous operation works
66 * - resid support for sg driver
68 * Revision 1.19 1999/11/02 22:39:59 fischer
69 * - moved leading comments to README.aha152x
70 * - new additional module parameters
72 * - support for the Tripace TC1550 controller
73 * - interrupt handling changed
75 * Revision 1.18 1996/09/07 20:10:40 fischer
76 * - fixed can_queue handling (multiple outstanding commands working again)
78 * Revision 1.17 1996/08/17 16:05:14 fischer
79 * - biosparam improved
80 * - interrupt verification
81 * - updated documentation
84 * Revision 1.16 1996/06/09 00:04:56 root
85 * - added configuration symbols for insmod (aha152x/aha152x1)
87 * Revision 1.15 1996/04/30 14:52:06 fischer
89 * - support for extended translation for >1GB disks
91 * Revision 1.14 1996/01/17 15:11:20 fischer
92 * - fixed lockup in MESSAGE IN phase after reconnection
94 * Revision 1.13 1996/01/09 02:15:53 fischer
96 * - moved request_irq behind controller initialization
97 * (to avoid spurious interrupts)
99 * Revision 1.12 1995/12/16 12:26:07 fischer
101 * - configurable RESET delay added
103 * Revision 1.11 1995/12/06 21:18:35 fischer
104 * - some minor updates
106 * Revision 1.10 1995/07/22 19:18:45 fischer
107 * - support for 2 controllers
108 * - started synchronous data transfers (not working yet)
110 * Revision 1.9 1995/03/18 09:20:24 root
111 * - patches for PCMCIA and modules
113 * Revision 1.8 1995/01/21 22:07:19 root
114 * - snarf_region => request_region
115 * - aha152x_intr interface change
117 * Revision 1.7 1995/01/02 23:19:36 root
118 * - updated COMMAND_SIZE to cmd_len
119 * - changed sti() to restore_flags()
120 * - fixed some #ifdef which generated warnings
122 * Revision 1.6 1994/11/24 20:35:27 root
123 * - problem with odd number of bytes in fifo fixed
125 * Revision 1.5 1994/10/30 14:39:56 root
127 * - debugging improved
129 * Revision 1.4 1994/09/12 11:33:01 root
130 * - irqaction to request_irq
133 * Revision 1.3 1994/08/04 13:53:05 root
134 * - updates for mid-level-driver changes
135 * - accept unexpected BUSFREE phase as error condition
136 * - parity check now configurable
138 * Revision 1.2 1994/07/03 12:56:36 root
139 * - cleaned up debugging code
140 * - more tweaking on reset delays
141 * - updated abort/reset code (pretty untested...)
143 * Revision 1.1 1994/05/28 21:18:49 root
144 * - update for mid-level interface change (abort-reset)
145 * - delays after resets adjusted for some slow devices
147 * Revision 1.0 1994/03/25 12:52:00 root
148 * - Fixed "more data than expected" problem
149 * - added new BIOS signatures
151 * Revision 0.102 1994/01/31 20:44:12 root
152 * - minor changes in insw/outsw handling
154 * Revision 0.101 1993/12/13 01:16:27 root
155 * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
156 * fixes problems with CD-ROM sector size detection & media change)
158 * Revision 0.100 1993/12/10 16:58:47 root
159 * - fix for unsuccessful selections in case of non-continuous id assignments
162 * Revision 0.99 1993/10/24 16:19:59 root
163 * - fixed DATA IN (rare read errors gone)
165 * Revision 0.98 1993/10/17 12:54:44 root
166 * - fixed some recent fixes (shame on me)
167 * - moved initialization of scratch area to aha152x_queue
169 * Revision 0.97 1993/10/09 18:53:53 root
170 * - DATA IN fixed. Rarely left data in the fifo.
172 * Revision 0.96 1993/10/03 00:53:59 root
173 * - minor changes on DATA IN
175 * Revision 0.95 1993/09/24 10:36:01 root
176 * - change handling of MSGI after reselection
180 * Revision 0.94 1993/09/18 14:08:22 root
181 * - fixed bug in multiple outstanding command code
182 * - changed detection
183 * - support for kernel command line configuration
185 * - changed message handling
187 * Revision 0.93 1993/09/15 20:41:19 root
188 * - fixed bugs with multiple outstanding commands
190 * Revision 0.92 1993/09/13 02:46:33 root
191 * - multiple outstanding commands work (no problems with IBM drive)
193 * Revision 0.91 1993/09/12 20:51:46 root
194 * added multiple outstanding commands
195 * (some problem with this $%&? IBM device remain)
197 * Revision 0.9 1993/09/12 11:11:22 root
198 * - corrected auto-configuration
199 * - changed the auto-configuration (added some '#define's)
200 * - added support for dis-/reconnection
202 * Revision 0.8 1993/09/06 23:09:39 root
203 * - added support for the drive activity light
206 * Revision 0.7 1993/09/05 14:30:15 root
207 * - improved phase detection
208 * - now using the new snarf_region code of 0.99pl13
210 * Revision 0.6 1993/09/02 11:01:38 root
211 * first public release; added some signatures and biosparam()
213 * Revision 0.5 1993/08/30 10:23:30 root
214 * fixed timing problems with my IBM drive
216 * Revision 0.4 1993/08/29 14:06:52 root
217 * fixed some problems with timeouts due incomplete commands
219 * Revision 0.3 1993/08/28 15:55:03 root
220 * writing data works too. mounted and worked on a dos partition
222 * Revision 0.2 1993/08/27 22:42:07 root
223 * reading data works. Mounted a msdos partition.
225 * Revision 0.1 1993/08/25 13:38:30 root
226 * first "damn thing doesn't work" version
228 * Revision 0.0 1993/08/14 19:54:25 root
229 * empty function bodies; detect() works.
232 **************************************************************************
234 see Documentation/scsi/aha152x.txt for configuration details
236 **************************************************************************/
238 #include <linux/module.h>
239 #include <linux/sched.h>
242 #include <linux/blkdev.h>
243 #include <asm/system.h>
244 #include <linux/errno.h>
245 #include <linux/string.h>
246 #include <linux/wait.h>
247 #include <linux/ioport.h>
248 #include <linux/delay.h>
249 #include <linux/proc_fs.h>
250 #include <linux/interrupt.h>
251 #include <linux/init.h>
252 #include <linux/kernel.h>
253 #include <linux/isapnp.h>
254 #include <linux/spinlock.h>
255 #include <linux/workqueue.h>
256 #include <asm/semaphore.h>
257 #include <scsi/scsicam.h>
260 #include <scsi/scsi_dbg.h>
261 #include <scsi/scsi_host.h>
262 #include <scsi/scsi_transport_spi.h>
268 /* For PCMCIA cards, always use AUTOCONF */
269 #if defined(PCMCIA) || defined(MODULE)
270 #if !defined(AUTOCONF)
275 #if !defined(AUTOCONF) && !defined(SETUP0)
276 #error define AUTOCONF or SETUP0
279 #if defined(AHA152X_DEBUG)
280 #define DEBUG_DEFAULT debug_eh
282 #define DPRINTK(when,msgs...) \
283 do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
285 #define DO_LOCK(flags) \
287 if(spin_is_locked(&QLOCK)) { \
288 DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
290 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
291 spin_lock_irqsave(&QLOCK,flags); \
292 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
293 QLOCKER=__FUNCTION__; \
297 #define DO_UNLOCK(flags) \
299 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
300 spin_unlock_irqrestore(&QLOCK,flags); \
301 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
302 QLOCKER="(not locked)"; \
307 #define DPRINTK(when,msgs...)
308 #define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
309 #define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
312 #define LEAD "(scsi%d:%d:%d) "
313 #define WARN_LEAD KERN_WARNING LEAD
314 #define INFO_LEAD KERN_INFO LEAD
315 #define NOTE_LEAD KERN_NOTICE LEAD
316 #define ERR_LEAD KERN_ERR LEAD
317 #define DEBUG_LEAD KERN_DEBUG LEAD
318 #define CMDINFO(cmd) \
319 (cmd) ? ((cmd)->device->host->host_no) : -1, \
320 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
321 (cmd) ? ((cmd)->device->lun & 0x07) : -1
323 #define DELAY_DEFAULT 1000
331 #define IRQ_MAX (NR_IRQS-1)
338 not_issued = 0x0001, /* command not yet issued */
339 selecting = 0x0002, /* target is beeing selected */
340 identified = 0x0004, /* IDENTIFY was sent */
341 disconnected = 0x0008, /* target disconnected */
342 completed = 0x0010, /* target sent COMMAND COMPLETE */
343 aborted = 0x0020, /* ABORT was sent */
344 resetted = 0x0040, /* BUS DEVICE RESET was sent */
345 spiordy = 0x0080, /* waiting for SPIORDY to raise */
346 syncneg = 0x0100, /* synchronous negotiation in progress */
347 aborting = 0x0200, /* ABORT is pending */
348 resetting = 0x0400, /* BUS DEVICE RESET is pending */
349 check_condition = 0x0800, /* requesting sense after CHECK CONDITION */
352 MODULE_AUTHOR("Jürgen Fischer");
353 MODULE_DESCRIPTION(AHA152X_REVID);
354 MODULE_LICENSE("GPL");
358 static int io[] = {0, 0};
359 module_param_array(io, int, NULL, 0);
360 MODULE_PARM_DESC(io,"base io address of controller");
362 static int irq[] = {0, 0};
363 module_param_array(irq, int, NULL, 0);
364 MODULE_PARM_DESC(irq,"interrupt for controller");
366 static int scsiid[] = {7, 7};
367 module_param_array(scsiid, int, NULL, 0);
368 MODULE_PARM_DESC(scsiid,"scsi id of controller");
370 static int reconnect[] = {1, 1};
371 module_param_array(reconnect, int, NULL, 0);
372 MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
374 static int parity[] = {1, 1};
375 module_param_array(parity, int, NULL, 0);
376 MODULE_PARM_DESC(parity,"use scsi parity");
378 static int sync[] = {1, 1};
379 module_param_array(sync, int, NULL, 0);
380 MODULE_PARM_DESC(sync,"use synchronous transfers");
382 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
383 module_param_array(delay, int, NULL, 0);
384 MODULE_PARM_DESC(delay,"scsi reset delay");
386 static int exttrans[] = {0, 0};
387 module_param_array(exttrans, int, NULL, 0);
388 MODULE_PARM_DESC(exttrans,"use extended translation");
390 #if !defined(AHA152X_DEBUG)
391 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
392 module_param_array(aha152x, int, NULL, 0);
393 MODULE_PARM_DESC(aha152x, "parameters for first controller");
395 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
396 module_param_array(aha152x1, int, NULL, 0);
397 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
399 static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
400 module_param_array(debug, int, NULL, 0);
401 MODULE_PARM_DESC(debug, "flags for driver debugging");
403 static int aha152x[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
404 module_param_array(aha152x, int, NULL, 0);
405 MODULE_PARM_DESC(aha152x, "parameters for first controller");
407 static int aha152x1[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
408 module_param_array(aha152x1, int, NULL, 0);
409 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
410 #endif /* !defined(AHA152X_DEBUG) */
414 static struct isapnp_device_id id_table[] __devinitdata = {
415 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
416 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1505), 0 },
417 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
418 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1530), 0 },
419 { ISAPNP_DEVICE_SINGLE_END, }
421 MODULE_DEVICE_TABLE(isapnp, id_table);
426 static int registered_count=0;
427 static struct Scsi_Host *aha152x_host[2];
428 static struct scsi_host_template aha152x_driver_template;
431 * internal states of the host
453 * current state information of the host
456 struct aha152x_hostdata {
458 /* pending commands to issue */
460 Scsi_Cmnd *current_SC;
461 /* current command on the bus */
463 Scsi_Cmnd *disconnected_SC;
464 /* commands that disconnected */
467 /* command that was completed */
472 #if defined(AHA152X_DEBUG)
474 /* which function has the lock */
475 int lockerl; /* where did it get it */
477 int debug; /* current debugging setting */
480 #if defined(AHA152X_STAT)
483 int busfree_without_any_action;
484 int busfree_without_old_command;
485 int busfree_without_new_command;
486 int busfree_without_done_command;
487 int busfree_with_check_condition;
489 int count_trans[maxstate];
490 unsigned long time[maxstate];
493 int commands; /* current number of commands */
495 int reconnect; /* disconnection allowed */
496 int parity; /* parity checking enabled */
497 int synchronous; /* synchronous transferes enabled */
498 int delay; /* reset out delay */
499 int ext_trans; /* extended translation enabled */
501 int swint; /* software-interrupt was fired during detect() */
502 int service; /* bh needs to be run */
503 int in_intr; /* bh is running */
507 last state different from current state */
508 enum aha152x_state state, prevstate, laststate;
511 /* reconnecting target */
513 unsigned char syncrate[8];
514 /* current synchronous transfer agreements */
516 unsigned char syncneg[8];
517 /* 0: no negotiation;
518 * 1: negotiation in progress;
519 * 2: negotiation completed
523 /* number of sent bytes of current command */
526 /* number of received message bytes */
527 unsigned char msgi[256];
528 /* received message bytes */
530 int msgo_i, msgo_len;
531 /* number of sent bytes and length of current messages */
532 unsigned char msgo[256];
533 /* pending messages */
536 /* number of sent/received bytes in dataphase */
538 unsigned long io_port0;
539 unsigned long io_port1;
542 struct pnp_dev *pnpdev;
548 * host specific command extension
551 struct aha152x_scdata {
552 Scsi_Cmnd *next; /* next sc in queue */
553 struct semaphore *sem; /* semaphore to block on */
557 /* access macros for hostdata */
559 #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
561 #define HOSTNO ((shpnt)->host_no)
563 #define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
564 #define DONE_SC (HOSTDATA(shpnt)->done_SC)
565 #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
566 #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
567 #define QLOCK (HOSTDATA(shpnt)->lock)
568 #define QLOCKER (HOSTDATA(shpnt)->locker)
569 #define QLOCKERL (HOSTDATA(shpnt)->lockerl)
571 #define STATE (HOSTDATA(shpnt)->state)
572 #define PREVSTATE (HOSTDATA(shpnt)->prevstate)
573 #define LASTSTATE (HOSTDATA(shpnt)->laststate)
575 #define RECONN_TARGET (HOSTDATA(shpnt)->target)
577 #define CMD_I (HOSTDATA(shpnt)->cmd_i)
579 #define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
580 #define MSGO_I (HOSTDATA(shpnt)->msgo_i)
581 #define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
582 #define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
584 #define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
585 #define MSGILEN (HOSTDATA(shpnt)->msgi_len)
586 #define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
588 #define DATA_LEN (HOSTDATA(shpnt)->data_len)
590 #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
591 #define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
593 #define DELAY (HOSTDATA(shpnt)->delay)
594 #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
595 #define TC1550 (HOSTDATA(shpnt)->tc1550)
596 #define RECONNECT (HOSTDATA(shpnt)->reconnect)
597 #define PARITY (HOSTDATA(shpnt)->parity)
598 #define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
600 #define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
601 #define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
603 #define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
604 #define SCNEXT(SCpnt) SCDATA(SCpnt)->next
605 #define SCSEM(SCpnt) SCDATA(SCpnt)->sem
607 #define SG_ADDRESS(buffer) ((char *) (page_address((buffer)->page)+(buffer)->offset))
610 static void seldi_run(struct Scsi_Host *shpnt);
611 static void seldo_run(struct Scsi_Host *shpnt);
612 static void selto_run(struct Scsi_Host *shpnt);
613 static void busfree_run(struct Scsi_Host *shpnt);
615 static void msgo_init(struct Scsi_Host *shpnt);
616 static void msgo_run(struct Scsi_Host *shpnt);
617 static void msgo_end(struct Scsi_Host *shpnt);
619 static void cmd_init(struct Scsi_Host *shpnt);
620 static void cmd_run(struct Scsi_Host *shpnt);
621 static void cmd_end(struct Scsi_Host *shpnt);
623 static void datai_init(struct Scsi_Host *shpnt);
624 static void datai_run(struct Scsi_Host *shpnt);
625 static void datai_end(struct Scsi_Host *shpnt);
627 static void datao_init(struct Scsi_Host *shpnt);
628 static void datao_run(struct Scsi_Host *shpnt);
629 static void datao_end(struct Scsi_Host *shpnt);
631 static void status_run(struct Scsi_Host *shpnt);
633 static void msgi_run(struct Scsi_Host *shpnt);
634 static void msgi_end(struct Scsi_Host *shpnt);
636 static void parerr_run(struct Scsi_Host *shpnt);
637 static void rsti_run(struct Scsi_Host *shpnt);
639 static void is_complete(struct Scsi_Host *shpnt);
647 void (*init)(struct Scsi_Host *);
648 void (*run)(struct Scsi_Host *);
649 void (*end)(struct Scsi_Host *);
652 { "idle", NULL, NULL, NULL, 0},
653 { "unknown", NULL, NULL, NULL, 0},
654 { "seldo", NULL, seldo_run, NULL, 0},
655 { "seldi", NULL, seldi_run, NULL, 0},
656 { "selto", NULL, selto_run, NULL, 0},
657 { "busfree", NULL, busfree_run, NULL, 0},
658 { "msgo", msgo_init, msgo_run, msgo_end, 1},
659 { "cmd", cmd_init, cmd_run, cmd_end, 1},
660 { "msgi", NULL, msgi_run, msgi_end, 1},
661 { "status", NULL, status_run, NULL, 1},
662 { "datai", datai_init, datai_run, datai_end, 0},
663 { "datao", datao_init, datao_run, datao_end, 0},
664 { "parerr", NULL, parerr_run, NULL, 0},
665 { "rsti", NULL, rsti_run, NULL, 0},
668 /* setup & interrupt */
669 static irqreturn_t intr(int irq, void *dev_id, struct pt_regs *);
670 static void reset_ports(struct Scsi_Host *shpnt);
671 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
672 static void done(struct Scsi_Host *shpnt, int error);
675 static void disp_ports(struct Scsi_Host *shpnt);
676 static void show_command(Scsi_Cmnd * ptr);
677 static void show_queues(struct Scsi_Host *shpnt);
678 static void disp_enintr(struct Scsi_Host *shpnt);
685 static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
689 SCNEXT(new_SC) = NULL;
693 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
695 SCNEXT(end) = new_SC;
699 static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
711 static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
713 Scsi_Cmnd *ptr, *prev;
715 for (ptr = *SC, prev = NULL;
716 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
717 prev = ptr, ptr = SCNEXT(ptr))
722 SCNEXT(prev) = SCNEXT(ptr);
732 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
734 Scsi_Cmnd *ptr, *prev;
736 for (ptr = *SC, prev = NULL;
738 prev = ptr, ptr = SCNEXT(ptr))
743 SCNEXT(prev) = SCNEXT(ptr);
753 static inline struct Scsi_Host *lookup_irq(int irqno)
757 for(i=0; i<ARRAY_SIZE(aha152x_host); i++)
758 if(aha152x_host[i] && aha152x_host[i]->irq==irqno)
759 return aha152x_host[i];
764 static irqreturn_t swintr(int irqno, void *dev_id, struct pt_regs *regs)
766 struct Scsi_Host *shpnt = lookup_irq(irqno);
769 printk(KERN_ERR "aha152x: catched software interrupt %d for unknown controller.\n", irqno);
773 HOSTDATA(shpnt)->swint++;
775 SETPORT(DMACNTRL0, INTEN);
779 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
781 struct Scsi_Host *shpnt;
783 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
785 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
789 /* need to have host registered before triggering any interrupt */
790 aha152x_host[registered_count] = shpnt;
792 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
794 shpnt->io_port = setup->io_port;
795 shpnt->n_io_port = IO_RANGE;
796 shpnt->irq = setup->irq;
798 if (!setup->tc1550) {
799 HOSTIOPORT0 = setup->io_port;
800 HOSTIOPORT1 = setup->io_port;
802 HOSTIOPORT0 = setup->io_port+0x10;
803 HOSTIOPORT1 = setup->io_port-0x10;
806 spin_lock_init(&QLOCK);
807 RECONNECT = setup->reconnect;
808 SYNCHRONOUS = setup->synchronous;
809 PARITY = setup->parity;
810 DELAY = setup->delay;
811 EXT_TRANS = setup->ext_trans;
813 #if defined(AHA152X_DEBUG)
814 HOSTDATA(shpnt)->debug = setup->debug;
817 SETPORT(SCSIID, setup->scsiid << 4);
818 shpnt->this_id = setup->scsiid;
820 if (setup->reconnect)
821 shpnt->can_queue = AHA152X_MAXQUEUE;
824 printk("aha152x: resetting bus...\n");
825 SETPORT(SCSISEQ, SCSIRSTO);
834 "vital data: rev=%x, "
835 "io=0x%03lx (0x%03lx/0x%03lx), "
842 "extended translation=%s\n",
843 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
845 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
848 RECONNECT ? "enabled" : "disabled",
849 PARITY ? "enabled" : "disabled",
850 SYNCHRONOUS ? "enabled" : "disabled",
852 EXT_TRANS ? "enabled" : "disabled");
854 /* not expecting any interrupts */
858 if( request_irq(shpnt->irq, swintr, SA_INTERRUPT|SA_SHIRQ, "aha152x", shpnt) ) {
859 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
863 HOSTDATA(shpnt)->swint = 0;
865 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
868 SETPORT(DMACNTRL0, SWINT|INTEN);
870 free_irq(shpnt->irq, shpnt);
872 if (!HOSTDATA(shpnt)->swint) {
873 if (TESTHI(DMASTAT, INTSTAT)) {
879 SETPORT(DMACNTRL0, INTEN);
881 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
882 "Please verify.\n", shpnt->host_no, shpnt->irq);
888 /* clear interrupts */
889 SETPORT(SSTAT0, 0x7f);
890 SETPORT(SSTAT1, 0xef);
892 if ( request_irq(shpnt->irq, intr, SA_INTERRUPT|SA_SHIRQ, "aha152x", shpnt) ) {
893 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
897 if( scsi_add_host(shpnt, NULL) ) {
898 free_irq(shpnt->irq, shpnt);
899 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
903 scsi_scan_host(shpnt);
910 aha152x_host[registered_count]=NULL;
911 scsi_host_put(shpnt);
916 void aha152x_release(struct Scsi_Host *shpnt)
922 free_irq(shpnt->irq, shpnt);
926 release_region(shpnt->io_port, IO_RANGE);
930 if (HOSTDATA(shpnt)->pnpdev)
931 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
934 scsi_remove_host(shpnt);
935 scsi_host_put(shpnt);
940 * setup controller to generate interrupts depending
941 * on current state (lock has to be acquired)
944 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
947 CURRENT_SC->SCp.phase |= 1 << 16;
949 if(CURRENT_SC->SCp.phase & selecting) {
950 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
951 SETPORT(SSTAT1, SELTO);
952 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
953 SETPORT(SIMODE1, ENSELTIMO);
955 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
956 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
957 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
959 } else if(STATE==seldi) {
960 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
962 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
964 DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
966 DISCONNECTED_SC ? "(reselection)" : "",
967 ISSUE_SC ? "(busfree)" : "");
968 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
969 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
972 if(!HOSTDATA(shpnt)->in_intr)
973 SETBITS(DMACNTRL0, INTEN);
975 return TESTHI(DMASTAT, INTSTAT);
980 * Queue a command and setup interrupts for a free bus.
982 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct semaphore *sem, int phase, void (*done)(Scsi_Cmnd *))
984 struct Scsi_Host *shpnt = SCpnt->device->host;
987 #if defined(AHA152X_DEBUG)
988 if (HOSTDATA(shpnt)->debug & debug_queue) {
989 printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
990 CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len, SCpnt->use_sg, SCpnt->request_bufflen);
991 __scsi_print_command(SCpnt->cmnd);
995 SCpnt->scsi_done = done;
996 SCpnt->resid = SCpnt->request_bufflen;
997 SCpnt->SCp.phase = not_issued | phase;
998 SCpnt->SCp.Status = CHECK_CONDITION;
999 SCpnt->SCp.Message = 0;
1000 SCpnt->SCp.have_data_in = 0;
1001 SCpnt->SCp.sent_command = 0;
1003 if(SCpnt->SCp.phase & (resetting|check_condition)) {
1004 if(SCpnt->host_scribble==0 || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
1005 printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1009 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1010 if(SCpnt->host_scribble==0) {
1011 printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1016 SCNEXT(SCpnt) = NULL;
1019 /* setup scratch area
1020 SCp.ptr : buffer pointer
1021 SCp.this_residual : buffer length
1022 SCp.buffer : next buffer
1023 SCp.buffers_residual : left buffers in list
1024 SCp.phase : current state of the command */
1025 if (SCpnt->use_sg) {
1026 SCpnt->SCp.buffer = (struct scatterlist *) SCpnt->request_buffer;
1027 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
1028 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
1029 SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1;
1031 SCpnt->SCp.ptr = (char *) SCpnt->request_buffer;
1032 SCpnt->SCp.this_residual = SCpnt->request_bufflen;
1033 SCpnt->SCp.buffer = NULL;
1034 SCpnt->SCp.buffers_residual = 0;
1039 #if defined(AHA152X_STAT)
1040 HOSTDATA(shpnt)->total_commands++;
1043 /* Turn led on, when this is the first command. */
1044 HOSTDATA(shpnt)->commands++;
1045 if (HOSTDATA(shpnt)->commands==1)
1048 append_SC(&ISSUE_SC, SCpnt);
1050 if(!HOSTDATA(shpnt)->in_intr)
1051 setup_expected_interrupts(shpnt);
1062 static int aha152x_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1065 if(*SCpnt->cmnd == REQUEST_SENSE) {
1073 return aha152x_internal_queue(SCpnt, NULL, 0, done);
1081 static void reset_done(Scsi_Cmnd *SCpnt)
1084 struct Scsi_Host *shpnt = SCpnt->host;
1085 DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1090 printk(KERN_ERR "aha152x: reset_done w/o semaphore\n");
1098 static int aha152x_abort(Scsi_Cmnd *SCpnt)
1100 struct Scsi_Host *shpnt = SCpnt->device->host;
1102 unsigned long flags;
1104 #if defined(AHA152X_DEBUG)
1105 if(HOSTDATA(shpnt)->debug & debug_eh) {
1106 printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1113 ptr=remove_SC(&ISSUE_SC, SCpnt);
1116 DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1118 HOSTDATA(shpnt)->commands--;
1119 if (!HOSTDATA(shpnt)->commands)
1123 kfree(SCpnt->host_scribble);
1124 SCpnt->host_scribble=NULL;
1133 * for current command: queue ABORT for message out and raise ATN
1134 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1138 printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1143 static void timer_expired(unsigned long p)
1145 Scsi_Cmnd *SCp = (Scsi_Cmnd *)p;
1146 struct semaphore *sem = SCSEM(SCp);
1147 struct Scsi_Host *shpnt = SCp->device->host;
1148 unsigned long flags;
1150 /* remove command from issue queue */
1152 remove_SC(&ISSUE_SC, SCp);
1162 static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1164 struct Scsi_Host *shpnt = SCpnt->device->host;
1165 DECLARE_MUTEX_LOCKED(sem);
1166 struct timer_list timer;
1167 int ret, issued, disconnected;
1168 unsigned long flags;
1170 #if defined(AHA152X_DEBUG)
1171 if(HOSTDATA(shpnt)->debug & debug_eh) {
1172 printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1177 if(CURRENT_SC==SCpnt) {
1178 printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1183 issued = remove_SC(&ISSUE_SC, SCpnt)==0;
1184 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1189 SCpnt->request_buffer = NULL;
1190 SCpnt->request_bufflen = 0;
1193 timer.data = (unsigned long) SCpnt;
1194 timer.expires = jiffies + 100*HZ; /* 10s */
1195 timer.function = (void (*)(unsigned long)) timer_expired;
1197 aha152x_internal_queue(SCpnt, &sem, resetting, reset_done);
1202 SCpnt->cmd_len = SCpnt->old_cmd_len;
1203 SCpnt->use_sg = SCpnt->old_use_sg;
1204 SCpnt->request_buffer = SCpnt->buffer;
1205 SCpnt->request_bufflen = SCpnt->bufflen;
1209 if(SCpnt->SCp.phase & resetted) {
1210 HOSTDATA(shpnt)->commands--;
1211 if (!HOSTDATA(shpnt)->commands)
1213 kfree(SCpnt->host_scribble);
1214 SCpnt->host_scribble=NULL;
1220 append_SC(&ISSUE_SC, SCpnt);
1221 } else if(disconnected) {
1222 append_SC(&DISCONNECTED_SC, SCpnt);
1232 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1243 printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1247 if (!ptr->device->soft_reset) {
1248 DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1249 remove_SC(SCs, ptr);
1250 HOSTDATA(shpnt)->commands--;
1251 kfree(ptr->host_scribble);
1252 ptr->host_scribble=NULL;
1263 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1265 struct Scsi_Host *shpnt = SCpnt->device->host;
1266 unsigned long flags;
1270 #if defined(AHA152X_DEBUG)
1271 if(HOSTDATA(shpnt)->debug & debug_eh) {
1272 printk(DEBUG_LEAD "aha152x_bus_reset(%p)", CMDINFO(SCpnt), SCpnt);
1277 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1278 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1280 DPRINTK(debug_eh, DEBUG_LEAD "resetting bus\n", CMDINFO(SCpnt));
1282 SETPORT(SCSISEQ, SCSIRSTO);
1284 SETPORT(SCSISEQ, 0);
1287 DPRINTK(debug_eh, DEBUG_LEAD "bus resetted\n", CMDINFO(SCpnt));
1289 setup_expected_interrupts(shpnt);
1290 if(HOSTDATA(shpnt)->commands==0)
1300 * Restore default values to the AIC-6260 registers and reset the fifos
1303 static void reset_ports(struct Scsi_Host *shpnt)
1305 unsigned long flags;
1307 /* disable interrupts */
1308 SETPORT(DMACNTRL0, RSTFIFO);
1310 SETPORT(SCSISEQ, 0);
1312 SETPORT(SXFRCTL1, 0);
1313 SETPORT(SCSISIG, 0);
1316 /* clear all interrupt conditions */
1317 SETPORT(SSTAT0, 0x7f);
1318 SETPORT(SSTAT1, 0xef);
1320 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1322 SETPORT(DMACNTRL0, 0);
1323 SETPORT(DMACNTRL1, 0);
1325 SETPORT(BRSTCNTRL, 0xf1);
1327 /* clear SCSI fifos and transfer count */
1328 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1329 SETPORT(SXFRCTL0, CH1);
1332 setup_expected_interrupts(shpnt);
1337 * Reset the host (bus and controller)
1340 int aha152x_host_reset(Scsi_Cmnd * SCpnt)
1342 #if defined(AHA152X_DEBUG)
1343 struct Scsi_Host *shpnt = SCpnt->device->host;
1346 DPRINTK(debug_eh, DEBUG_LEAD "aha152x_host_reset(%p)\n", CMDINFO(SCpnt), SCpnt);
1348 aha152x_bus_reset(SCpnt);
1350 DPRINTK(debug_eh, DEBUG_LEAD "resetting ports\n", CMDINFO(SCpnt));
1351 reset_ports(SCpnt->device->host);
1357 * Return the "logical geometry"
1360 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1361 sector_t capacity, int *info_array)
1363 struct Scsi_Host *shpnt = sdev->host;
1365 /* try default translation */
1368 info_array[2] = (unsigned long)capacity / (64 * 32);
1370 /* for disks >1GB do some guessing */
1371 if (info_array[2] >= 1024) {
1374 /* try to figure out the geometry from the partition table */
1375 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1376 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1379 "aha152x: unable to verify geometry for disk with >1GB.\n"
1380 " using extended translation.\n");
1381 info_array[0] = 255;
1383 info_array[2] = (unsigned long)capacity / (255 * 63);
1386 "aha152x: unable to verify geometry for disk with >1GB.\n"
1387 " Using default translation. Please verify yourself.\n"
1388 " Perhaps you need to enable extended translation in the driver.\n"
1389 " See Documentation/scsi/aha152x.txt for details.\n");
1392 info_array[0] = info[0];
1393 info_array[1] = info[1];
1394 info_array[2] = info[2];
1396 if (info[0] == 255 && !EXT_TRANS) {
1398 "aha152x: current partition table is using extended translation.\n"
1399 " using it also, although it's not explicitly enabled.\n");
1408 * Internal done function
1411 static void done(struct Scsi_Host *shpnt, int error)
1415 printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1417 DONE_SC = CURRENT_SC;
1419 DONE_SC->result = error;
1421 printk(KERN_ERR "aha152x: done() called outside of command\n");
1424 static struct work_struct aha152x_tq;
1427 * Run service completions on the card with interrupts enabled.
1430 static void run(void)
1433 for (i = 0; i<ARRAY_SIZE(aha152x_host); i++) {
1434 struct Scsi_Host *shpnt = aha152x_host[i];
1435 if (shpnt && HOSTDATA(shpnt)->service) {
1436 HOSTDATA(shpnt)->service=0;
1443 * Interrupts handler
1447 static irqreturn_t intr(int irqno, void *dev_id, struct pt_regs *regs)
1449 struct Scsi_Host *shpnt = lookup_irq(irqno);
1450 unsigned char rev, dmacntrl0;
1453 printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno);
1458 * Read a couple of registers that are known to not be all 1's. If
1459 * we read all 1's (-1), that means that either:
1461 * a. The host adapter chip has gone bad, and we cannot control it,
1463 * b. The host adapter is a PCMCIA card that has been ejected
1465 * In either case, we cannot do anything with the host adapter at
1466 * this point in time. So just ignore the interrupt and return.
1467 * In the latter case, the interrupt might actually be meant for
1468 * someone else sharing this IRQ, and that driver will handle it.
1471 dmacntrl0 = GETPORT(DMACNTRL0);
1472 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1475 /* no more interrupts from the controller, while we're busy.
1476 INTEN is restored by the BH handler */
1477 CLRBITS(DMACNTRL0, INTEN);
1480 /* check if there is already something to be
1481 serviced; should not happen */
1482 if(HOSTDATA(shpnt)->service) {
1483 printk(KERN_ERR "aha152x%d: lost interrupt (%d)\n", HOSTNO, HOSTDATA(shpnt)->service);
1488 /* Poke the BH handler */
1489 HOSTDATA(shpnt)->service++;
1490 INIT_WORK(&aha152x_tq, (void *) run, NULL);
1491 schedule_work(&aha152x_tq);
1497 * - handle completition/disconnection/error of current command
1498 * - start selection for next command (if any)
1500 static void busfree_run(struct Scsi_Host *shpnt)
1502 unsigned long flags;
1503 #if defined(AHA152X_STAT)
1507 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1508 SETPORT(SXFRCTL0, CH1);
1510 SETPORT(SSTAT1, CLRBUSFREE);
1513 #if defined(AHA152X_STAT)
1516 CURRENT_SC->SCp.phase &= ~syncneg;
1518 if(CURRENT_SC->SCp.phase & completed) {
1519 /* target sent COMMAND COMPLETE */
1520 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1522 } else if(CURRENT_SC->SCp.phase & aborted) {
1523 DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1524 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1526 } else if(CURRENT_SC->SCp.phase & resetted) {
1527 DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1528 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1530 } else if(CURRENT_SC->SCp.phase & disconnected) {
1531 /* target sent DISCONNECT */
1532 DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1533 CMDINFO(CURRENT_SC),
1535 CURRENT_SC->request_bufflen);
1536 #if defined(AHA152X_STAT)
1537 HOSTDATA(shpnt)->disconnections++;
1539 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1540 CURRENT_SC->SCp.phase |= 1 << 16;
1544 done(shpnt, DID_ERROR << 16);
1546 #if defined(AHA152X_STAT)
1548 HOSTDATA(shpnt)->busfree_without_old_command++;
1555 #if defined(AHA152X_STAT)
1559 if(DONE_SC->SCp.phase & check_condition) {
1561 if(HOSTDATA(shpnt)->debug & debug_eh) {
1562 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1563 scsi_print_sense("bh", DONE_SC);
1567 /* restore old command */
1568 memcpy((void *) DONE_SC->cmnd, (void *) DONE_SC->data_cmnd, sizeof(DONE_SC->data_cmnd));
1569 DONE_SC->request_buffer = DONE_SC->buffer;
1570 DONE_SC->request_bufflen = DONE_SC->bufflen;
1571 DONE_SC->use_sg = DONE_SC->old_use_sg;
1572 DONE_SC->cmd_len = DONE_SC->old_cmd_len;
1574 DONE_SC->SCp.Status = 0x02;
1576 HOSTDATA(shpnt)->commands--;
1577 if (!HOSTDATA(shpnt)->commands)
1578 SETPORT(PORTA, 0); /* turn led off */
1579 } else if(DONE_SC->SCp.Status==0x02) {
1580 #if defined(AHA152X_STAT)
1581 HOSTDATA(shpnt)->busfree_with_check_condition++;
1584 DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1587 if(!(DONE_SC->SCp.Status & not_issued)) {
1588 Scsi_Cmnd *ptr = DONE_SC;
1591 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1594 ptr->cmnd[0] = REQUEST_SENSE;
1598 ptr->cmnd[4] = sizeof(ptr->sense_buffer);
1602 ptr->request_buffer = ptr->sense_buffer;
1603 ptr->request_bufflen = sizeof(ptr->sense_buffer);
1606 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1610 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1615 if(DONE_SC && DONE_SC->scsi_done) {
1616 #if defined(AHA152X_DEBUG)
1617 int hostno=DONE_SC->device->host->host_no;
1618 int id=DONE_SC->device->id & 0xf;
1619 int lun=DONE_SC->device->lun & 0x7;
1621 Scsi_Cmnd *ptr = DONE_SC;
1624 /* turn led off, when no commands are in the driver */
1625 HOSTDATA(shpnt)->commands--;
1626 if (!HOSTDATA(shpnt)->commands)
1627 SETPORT(PORTA, 0); /* turn led off */
1629 if(ptr->scsi_done != reset_done) {
1630 kfree(ptr->host_scribble);
1631 ptr->host_scribble=NULL;
1635 DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1636 ptr->scsi_done(ptr);
1637 DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1642 #if defined(AHA152X_STAT)
1644 HOSTDATA(shpnt)->busfree_without_done_command++;
1649 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1654 #if defined(AHA152X_STAT)
1657 CURRENT_SC->SCp.phase |= selecting;
1659 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1661 /* clear selection timeout */
1662 SETPORT(SSTAT1, SELTO);
1664 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1665 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1666 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1668 #if defined(AHA152X_STAT)
1669 HOSTDATA(shpnt)->busfree_without_new_command++;
1671 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1674 #if defined(AHA152X_STAT)
1676 HOSTDATA(shpnt)->busfree_without_any_action++;
1681 * Selection done (OUT)
1682 * - queue IDENTIFY message and SDTR to selected target for message out
1683 * (ATN asserted automagically via ENAUTOATNO in busfree())
1685 static void seldo_run(struct Scsi_Host *shpnt)
1687 SETPORT(SCSISIG, 0);
1688 SETPORT(SSTAT1, CLRBUSFREE);
1689 SETPORT(SSTAT1, CLRPHASECHG);
1691 CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1693 SETPORT(SCSISEQ, 0);
1695 if (TESTLO(SSTAT0, SELDO)) {
1696 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1697 done(shpnt, DID_NO_CONNECT << 16);
1701 SETPORT(SSTAT0, CLRSELDO);
1703 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1705 if (CURRENT_SC->SCp.phase & aborting) {
1707 } else if (CURRENT_SC->SCp.phase & resetting) {
1708 ADDMSGO(BUS_DEVICE_RESET);
1709 } else if (SYNCNEG==0 && SYNCHRONOUS) {
1710 CURRENT_SC->SCp.phase |= syncneg;
1711 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1712 SYNCNEG=1; /* negotiation in progress */
1720 * - return command to mid-level with failure cause
1723 static void selto_run(struct Scsi_Host *shpnt)
1725 SETPORT(SCSISEQ, 0);
1726 SETPORT(SSTAT1, CLRSELTIMO);
1728 DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1731 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1735 CURRENT_SC->SCp.phase &= ~selecting;
1737 if (CURRENT_SC->SCp.phase & aborted) {
1738 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1739 done(shpnt, DID_ABORT << 16);
1740 } else if (TESTLO(SSTAT0, SELINGO)) {
1741 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1742 done(shpnt, DID_BUS_BUSY << 16);
1744 /* ARBITRATION won, but SELECTION failed */
1745 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1746 done(shpnt, DID_NO_CONNECT << 16);
1752 * - put current command back to issue queue
1753 * (reconnection of a disconnected nexus instead
1754 * of successful selection out)
1757 static void seldi_run(struct Scsi_Host *shpnt)
1761 unsigned long flags;
1763 SETPORT(SCSISIG, 0);
1764 SETPORT(SSTAT0, CLRSELDI);
1765 SETPORT(SSTAT1, CLRBUSFREE);
1766 SETPORT(SSTAT1, CLRPHASECHG);
1769 if(!(CURRENT_SC->SCp.phase & not_issued))
1770 printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1772 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1775 append_SC(&ISSUE_SC, CURRENT_SC);
1781 if(!DISCONNECTED_SC) {
1782 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1788 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1791 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1795 for(target=7; !(selid & (1 << target)); target--)
1798 if(selid & ~(1 << target)) {
1799 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1804 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1805 SETPORT(SCSISEQ, 0);
1807 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1809 RECONN_TARGET=target;
1810 DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1815 * - handle initial message after reconnection to identify
1816 * reconnecting nexus
1817 * - queue command on DISCONNECTED_SC on DISCONNECT message
1818 * - set completed flag on COMMAND COMPLETE
1819 * (other completition code moved to busfree_run)
1820 * - handle response to SDTR
1821 * - clear synchronous transfer agreements on BUS RESET
1823 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1826 static void msgi_run(struct Scsi_Host *shpnt)
1829 int sstat1 = GETPORT(SSTAT1);
1831 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1834 if(TESTLO(SSTAT0,SPIORDY)) {
1835 DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1839 ADDMSGI(GETPORT(SCSIDAT));
1841 #if defined(AHA152X_DEBUG)
1842 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1843 printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1844 spi_print_msg(&MSGI(0));
1850 if(LASTSTATE!=seldi) {
1851 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1855 * Handle reselection
1857 if(!(MSGI(0) & IDENTIFY_BASE)) {
1858 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1862 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1866 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1870 DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1872 CURRENT_SC->SCp.Message = MSGI(0);
1873 CURRENT_SC->SCp.phase &= ~disconnected;
1877 /* next message if any */
1881 CURRENT_SC->SCp.Message = MSGI(0);
1886 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1888 CURRENT_SC->SCp.phase |= disconnected;
1891 case COMMAND_COMPLETE:
1892 if(CURRENT_SC->SCp.phase & completed)
1893 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1895 CURRENT_SC->SCp.phase |= completed;
1898 case MESSAGE_REJECT:
1900 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1901 SYNCNEG=2; /* negotiation completed */
1903 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1909 case RESTORE_POINTERS:
1912 case EXTENDED_MESSAGE:
1913 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1914 /* not yet completed */
1924 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1928 if (!HOSTDATA(shpnt)->synchronous)
1931 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1932 spi_print_msg(&MSGI(0));
1935 ticks = (MSGI(3) * 4 + 49) / 50;
1938 /* negotiation in progress */
1939 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1940 ADDMSGO(MESSAGE_REJECT);
1941 printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1945 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1946 } else if (ticks <= 9 && MSGI(4) >= 1) {
1947 ADDMSGO(EXTENDED_MESSAGE);
1949 ADDMSGO(EXTENDED_SDTR);
1961 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1963 /* requested SDTR is too slow, do it asynchronously */
1964 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1965 ADDMSGO(MESSAGE_REJECT);
1968 SYNCNEG=2; /* negotiation completed */
1973 case BUS_DEVICE_RESET:
1977 for(i=0; i<8; i++) {
1978 HOSTDATA(shpnt)->syncrate[i]=0;
1979 HOSTDATA(shpnt)->syncneg[i]=0;
1985 case EXTENDED_MODIFY_DATA_POINTER:
1986 case EXTENDED_EXTENDED_IDENTIFY:
1989 ADDMSGO(MESSAGE_REJECT);
1999 static void msgi_end(struct Scsi_Host *shpnt)
2002 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
2004 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
2005 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
2006 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
2014 static void msgo_init(struct Scsi_Host *shpnt)
2017 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2018 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2020 printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2021 ADDMSGO(MESSAGE_REJECT);
2025 #if defined(AHA152X_DEBUG)
2026 if(HOSTDATA(shpnt)->debug & debug_msgo) {
2029 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2030 for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2041 static void msgo_run(struct Scsi_Host *shpnt)
2044 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2046 while(MSGO_I<MSGOLEN) {
2047 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2049 if(TESTLO(SSTAT0, SPIORDY)) {
2050 DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2054 if (MSGO_I==MSGOLEN-1) {
2055 /* Leave MESSAGE OUT after transfer */
2056 SETPORT(SSTAT1, CLRATNO);
2060 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2061 CURRENT_SC->SCp.phase |= identified;
2063 if (MSGO(MSGO_I)==ABORT)
2064 CURRENT_SC->SCp.phase |= aborted;
2066 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2067 CURRENT_SC->SCp.phase |= resetted;
2069 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2073 static void msgo_end(struct Scsi_Host *shpnt)
2075 if(MSGO_I<MSGOLEN) {
2076 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2078 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2091 static void cmd_init(struct Scsi_Host *shpnt)
2093 if (CURRENT_SC->SCp.sent_command) {
2094 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2095 done(shpnt, DID_ERROR << 16);
2099 #if defined(AHA152X_DEBUG)
2100 if (HOSTDATA(shpnt)->debug & debug_cmd) {
2101 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2102 __scsi_print_command(CURRENT_SC->cmnd);
2113 static void cmd_run(struct Scsi_Host *shpnt)
2115 if(CMD_I==CURRENT_SC->cmd_len) {
2116 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2120 while(CMD_I<CURRENT_SC->cmd_len) {
2121 DPRINTK(debug_cmd, DEBUG_LEAD "command byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), CURRENT_SC->cmnd[CMD_I], CMD_I, CURRENT_SC->cmd_len);
2123 if(TESTLO(SSTAT0, SPIORDY)) {
2124 DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2128 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2132 static void cmd_end(struct Scsi_Host *shpnt)
2134 if(CMD_I<CURRENT_SC->cmd_len)
2135 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2137 CURRENT_SC->SCp.sent_command++;
2144 static void status_run(struct Scsi_Host *shpnt)
2146 if(TESTLO(SSTAT0,SPIORDY)) {
2147 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2151 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2153 #if defined(AHA152X_DEBUG)
2154 if (HOSTDATA(shpnt)->debug & debug_status) {
2155 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2156 scsi_print_status(CURRENT_SC->SCp.Status);
2166 static void datai_init(struct Scsi_Host *shpnt)
2168 SETPORT(DMACNTRL0, RSTFIFO);
2169 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2171 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2172 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2174 SETPORT(SIMODE0, 0);
2175 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2178 DPRINTK(debug_datai,
2179 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2180 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2183 static void datai_run(struct Scsi_Host *shpnt)
2185 unsigned long the_time;
2186 int fifodata, data_count;
2189 * loop while the phase persists or the fifos are not empty
2192 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2193 /* FIXME: maybe this should be done by setting up
2194 * STCNT to trigger ENSWRAP interrupt, instead of
2195 * polling for DFIFOFULL
2197 the_time=jiffies + 100*HZ;
2198 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2201 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2202 printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2207 if(TESTHI(DMASTAT, DFIFOFULL)) {
2210 the_time=jiffies + 100*HZ;
2211 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2214 if(TESTLO(SSTAT2, SEMPTY)) {
2215 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2220 fifodata = GETPORT(FIFOSTAT);
2223 if(CURRENT_SC->SCp.this_residual>0) {
2224 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2225 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2226 CURRENT_SC->SCp.this_residual :
2228 fifodata -= data_count;
2230 if(data_count & 1) {
2231 DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2232 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2233 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2234 CURRENT_SC->SCp.this_residual--;
2236 SETPORT(DMACNTRL0, ENDMA);
2239 if(data_count > 1) {
2240 DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2242 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2243 CURRENT_SC->SCp.ptr += 2 * data_count;
2244 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2245 DATA_LEN += 2 * data_count;
2248 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2249 /* advance to next buffer */
2250 CURRENT_SC->SCp.buffers_residual--;
2251 CURRENT_SC->SCp.buffer++;
2252 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2253 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2256 } else if(fifodata>0) {
2257 printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2258 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2261 data=GETPORT(DATAPORT);
2262 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2266 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2270 if(TESTLO(DMASTAT, INTSTAT) ||
2271 TESTLO(DMASTAT, DFIFOEMP) ||
2272 TESTLO(SSTAT2, SEMPTY) ||
2273 GETPORT(FIFOSTAT)>0) {
2275 * something went wrong, if there's something left in the fifos
2276 * or the phase didn't change
2278 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2282 if(DATA_LEN!=GETSTCNT()) {
2284 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2285 CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2291 static void datai_end(struct Scsi_Host *shpnt)
2293 CURRENT_SC->resid -= GETSTCNT();
2295 DPRINTK(debug_datai,
2296 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2297 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid, GETSTCNT());
2299 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2300 SETPORT(DMACNTRL0, 0);
2307 static void datao_init(struct Scsi_Host *shpnt)
2309 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2310 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2312 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2313 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2315 SETPORT(SIMODE0, 0);
2316 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2318 DATA_LEN = CURRENT_SC->resid;
2320 DPRINTK(debug_datao,
2321 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2322 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2325 static void datao_run(struct Scsi_Host *shpnt)
2327 unsigned long the_time;
2330 /* until phase changes or all data sent */
2331 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2333 if(data_count > CURRENT_SC->SCp.this_residual)
2334 data_count=CURRENT_SC->SCp.this_residual;
2336 if(TESTLO(DMASTAT, DFIFOEMP)) {
2337 printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2342 if(data_count & 1) {
2343 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2344 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2345 CURRENT_SC->SCp.this_residual--;
2346 CURRENT_SC->resid--;
2347 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2350 if(data_count > 1) {
2352 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2353 CURRENT_SC->SCp.ptr += 2 * data_count;
2354 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2355 CURRENT_SC->resid -= 2 * data_count;
2358 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2359 /* advance to next buffer */
2360 CURRENT_SC->SCp.buffers_residual--;
2361 CURRENT_SC->SCp.buffer++;
2362 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2363 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2366 the_time=jiffies + 100*HZ;
2367 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2370 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2371 printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2378 static void datao_end(struct Scsi_Host *shpnt)
2380 if(TESTLO(DMASTAT, DFIFOEMP)) {
2381 int data_count = (DATA_LEN - CURRENT_SC->resid) - GETSTCNT();
2383 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2384 CMDINFO(CURRENT_SC),
2386 DATA_LEN-CURRENT_SC->resid,
2389 CURRENT_SC->resid += data_count;
2391 if(CURRENT_SC->use_sg) {
2392 data_count -= CURRENT_SC->SCp.ptr - SG_ADDRESS(CURRENT_SC->SCp.buffer);
2393 while(data_count>0) {
2394 CURRENT_SC->SCp.buffer--;
2395 CURRENT_SC->SCp.buffers_residual++;
2396 data_count -= CURRENT_SC->SCp.buffer->length;
2398 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) - data_count;
2399 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + data_count;
2401 CURRENT_SC->SCp.ptr -= data_count;
2402 CURRENT_SC->SCp.this_residual += data_count;
2406 DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2407 CMDINFO(CURRENT_SC),
2408 CURRENT_SC->request_bufflen,
2412 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2413 SETPORT(SXFRCTL0, CH1);
2415 SETPORT(DMACNTRL0, 0);
2419 * figure out what state we're in
2422 static int update_state(struct Scsi_Host *shpnt)
2425 unsigned int stat0 = GETPORT(SSTAT0);
2426 unsigned int stat1 = GETPORT(SSTAT1);
2431 if(stat1 & SCSIRSTI) {
2434 SETPORT(SSTAT1,SCSIRSTI);
2435 } else if(stat0 & SELDI && PREVSTATE==busfree) {
2437 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2439 } else if(stat1 & SELTO) {
2441 } else if(stat1 & BUSFREE) {
2443 SETPORT(SSTAT1,BUSFREE);
2444 } else if(stat1 & SCSIPERR) {
2446 SETPORT(SSTAT1,SCSIPERR);
2447 } else if(stat1 & REQINIT) {
2448 switch(GETPORT(SCSISIG) & P_MASK) {
2449 case P_MSGI: STATE=msgi; break;
2450 case P_MSGO: STATE=msgo; break;
2451 case P_DATAO: STATE=datao; break;
2452 case P_DATAI: STATE=datai; break;
2453 case P_STATUS: STATE=status; break;
2454 case P_CMD: STATE=cmd; break;
2459 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2460 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2464 if(STATE!=PREVSTATE) {
2465 LASTSTATE=PREVSTATE;
2472 * handle parity error
2474 * FIXME: in which phase?
2477 static void parerr_run(struct Scsi_Host *shpnt)
2479 printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2480 done(shpnt, DID_PARITY << 16);
2487 static void rsti_run(struct Scsi_Host *shpnt)
2491 printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2493 ptr=DISCONNECTED_SC;
2495 Scsi_Cmnd *next = SCNEXT(ptr);
2497 if (!ptr->device->soft_reset) {
2498 remove_SC(&DISCONNECTED_SC, ptr);
2500 kfree(ptr->host_scribble);
2501 ptr->host_scribble=NULL;
2503 ptr->result = DID_RESET << 16;
2504 ptr->scsi_done(ptr);
2510 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2511 done(shpnt, DID_RESET << 16 );
2516 * bottom-half handler
2519 static void is_complete(struct Scsi_Host *shpnt)
2522 unsigned long flags;
2526 if(HOSTDATA(shpnt)->in_intr) {
2528 /* aha152x_error never returns.. */
2529 aha152x_error(shpnt, "bottom-half already running!?");
2531 HOSTDATA(shpnt)->in_intr++;
2534 * loop while there are interrupt conditions pending
2538 unsigned long start = jiffies;
2541 dataphase=update_state(shpnt);
2543 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2546 * end previous state
2549 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2550 states[PREVSTATE].end(shpnt);
2553 * disable SPIO mode if previous phase used it
2554 * and this one doesn't
2557 if(states[PREVSTATE].spio && !states[STATE].spio) {
2558 SETPORT(SXFRCTL0, CH1);
2559 SETPORT(DMACNTRL0, 0);
2561 CURRENT_SC->SCp.phase &= ~spiordy;
2565 * accept current dataphase phase
2569 SETPORT(SSTAT0, REQINIT);
2570 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2571 SETPORT(SSTAT1, PHASECHG);
2575 * enable SPIO mode if previous didn't use it
2579 if(!states[PREVSTATE].spio && states[STATE].spio) {
2580 SETPORT(DMACNTRL0, 0);
2581 SETPORT(SXFRCTL0, CH1|SPIOEN);
2583 CURRENT_SC->SCp.phase |= spiordy;
2587 * initialize for new state
2590 if(PREVSTATE!=STATE && states[STATE].init)
2591 states[STATE].init(shpnt);
2594 * handle current state
2597 if(states[STATE].run)
2598 states[STATE].run(shpnt);
2600 printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2603 * setup controller to interrupt on
2604 * the next expected condition and
2605 * loop if it's already there
2609 pending=setup_expected_interrupts(shpnt);
2610 #if defined(AHA152X_STAT)
2611 HOSTDATA(shpnt)->count[STATE]++;
2612 if(PREVSTATE!=STATE)
2613 HOSTDATA(shpnt)->count_trans[STATE]++;
2614 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2617 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2621 * enable interrupts and leave bottom-half
2624 HOSTDATA(shpnt)->in_intr--;
2625 SETBITS(DMACNTRL0, INTEN);
2631 * Dump the current driver status and panic
2633 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2635 printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2637 panic("aha152x panic\n");
2641 * Display registers of AIC-6260
2643 static void disp_ports(struct Scsi_Host *shpnt)
2645 #if defined(AHA152X_DEBUG)
2648 printk("\n%s: %s(%s) ",
2649 CURRENT_SC ? "busy" : "waiting",
2651 states[PREVSTATE].name);
2653 s = GETPORT(SCSISEQ);
2654 printk("SCSISEQ( ");
2656 printk("TARGET MODE ");
2664 printk("AUTOATNO ");
2666 printk("AUTOATNI ");
2668 printk("AUTOATNP ");
2670 printk("SCSIRSTO ");
2673 printk(" SCSISIG(");
2674 s = GETPORT(SCSISIG);
2675 switch (s & P_MASK) {
2689 printk("MESSAGE OUT");
2692 printk("MESSAGE IN");
2695 printk("*invalid*");
2701 printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2704 s = GETPORT(SSTAT0);
2722 s = GETPORT(SSTAT1);
2728 printk("SCSIRSTI ");
2730 printk("PHASEMIS ");
2734 printk("SCSIPERR ");
2736 printk("PHASECHG ");
2744 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2763 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2770 printk("SCSIRSTI ");
2772 printk("PHASEMIS ");
2776 printk("SCSIPERR ");
2778 printk("PHASECHG ");
2783 printk("SXFRCTL0( ");
2785 s = GETPORT(SXFRCTL0);
2793 printk("CLRSTCNT ");
2802 s = GETPORT(SCSISIG);
2815 printk("SELID (%02x), ", GETPORT(SELID));
2817 printk("STCNT (%d), ", GETSTCNT());
2821 s = GETPORT(SSTAT2);
2828 printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2830 s = GETPORT(SSTAT3);
2831 printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2834 s = GETPORT(SSTAT4);
2843 printk("DMACNTRL0( ");
2844 s = GETPORT(DMACNTRL0);
2845 printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2846 printk("%s ", s & DMA ? "DMA" : "PIO");
2847 printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2858 printk("DMASTAT( ");
2859 s = GETPORT(DMASTAT);
2865 printk("DFIFOFULL ");
2867 printk("DFIFOEMP ");
2873 * display enabled interrupts
2875 static void disp_enintr(struct Scsi_Host *shpnt)
2879 printk(KERN_DEBUG "enabled interrupts ( ");
2881 s = GETPORT(SIMODE0);
2887 printk("ENSELINGO ");
2893 printk("ENSPIORDY ");
2895 printk("ENDMADONE ");
2897 s = GETPORT(SIMODE1);
2899 printk("ENSELTIMO ");
2901 printk("ENATNTARG ");
2903 printk("ENPHASEMIS ");
2905 printk("ENBUSFREE ");
2907 printk("ENSCSIPERR ");
2909 printk("ENPHASECHG ");
2911 printk("ENREQINIT ");
2916 * Show the command data of a command
2918 static void show_command(Scsi_Cmnd *ptr)
2920 scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2922 __scsi_print_command(ptr->cmnd);
2924 printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2925 ptr->request_bufflen, ptr->resid);
2927 if (ptr->SCp.phase & not_issued)
2928 printk("not issued|");
2929 if (ptr->SCp.phase & selecting)
2930 printk("selecting|");
2931 if (ptr->SCp.phase & identified)
2932 printk("identified|");
2933 if (ptr->SCp.phase & disconnected)
2934 printk("disconnected|");
2935 if (ptr->SCp.phase & completed)
2936 printk("completed|");
2937 if (ptr->SCp.phase & spiordy)
2939 if (ptr->SCp.phase & syncneg)
2941 if (ptr->SCp.phase & aborted)
2943 if (ptr->SCp.phase & resetted)
2944 printk("resetted|");
2946 printk("; next=0x%p\n", SCNEXT(ptr));
2948 printk("; next=(host scribble NULL)\n");
2953 * Dump the queued data
2955 static void show_queues(struct Scsi_Host *shpnt)
2958 unsigned long flags;
2961 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2962 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2966 printk(KERN_DEBUG "current_SC:\n");
2968 show_command(CURRENT_SC);
2970 printk(KERN_DEBUG "none\n");
2972 printk(KERN_DEBUG "disconnected_SC:\n");
2973 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2981 #define SPRINTF(args...) pos += sprintf(pos, ## args)
2983 static int get_command(char *pos, Scsi_Cmnd * ptr)
2988 SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
2989 (unsigned int) ptr, ptr->device->id, ptr->device->lun);
2991 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2992 SPRINTF("0x%02x ", ptr->cmnd[i]);
2994 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
2995 ptr->resid, ptr->SCp.this_residual, ptr->SCp.buffers_residual);
2997 if (ptr->SCp.phase & not_issued)
2998 SPRINTF("not issued|");
2999 if (ptr->SCp.phase & selecting)
3000 SPRINTF("selecting|");
3001 if (ptr->SCp.phase & disconnected)
3002 SPRINTF("disconnected|");
3003 if (ptr->SCp.phase & aborted)
3004 SPRINTF("aborted|");
3005 if (ptr->SCp.phase & identified)
3006 SPRINTF("identified|");
3007 if (ptr->SCp.phase & completed)
3008 SPRINTF("completed|");
3009 if (ptr->SCp.phase & spiordy)
3010 SPRINTF("spiordy|");
3011 if (ptr->SCp.phase & syncneg)
3012 SPRINTF("syncneg|");
3013 SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3015 return (pos - start);
3018 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3023 SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3025 s = GETPORT(SCSISEQ);
3026 SPRINTF("SCSISEQ( ");
3028 SPRINTF("TARGET MODE ");
3036 SPRINTF("AUTOATNO ");
3038 SPRINTF("AUTOATNI ");
3040 SPRINTF("AUTOATNP ");
3042 SPRINTF("SCSIRSTO ");
3045 SPRINTF(" SCSISIG(");
3046 s = GETPORT(SCSISIG);
3047 switch (s & P_MASK) {
3049 SPRINTF("DATA OUT");
3061 SPRINTF("MESSAGE OUT");
3064 SPRINTF("MESSAGE IN");
3067 SPRINTF("*invalid*");
3073 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3076 s = GETPORT(SSTAT0);
3084 SPRINTF("SELINGO ");
3090 SPRINTF("SPIORDY ");
3092 SPRINTF("DMADONE ");
3094 s = GETPORT(SSTAT1);
3098 SPRINTF("ATNTARG ");
3100 SPRINTF("SCSIRSTI ");
3102 SPRINTF("PHASEMIS ");
3104 SPRINTF("BUSFREE ");
3106 SPRINTF("SCSIPERR ");
3108 SPRINTF("PHASECHG ");
3110 SPRINTF("REQINIT ");
3116 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3125 SPRINTF("SELINGO ");
3131 SPRINTF("SPIORDY ");
3133 SPRINTF("DMADONE ");
3135 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3140 SPRINTF("ATNTARG ");
3142 SPRINTF("SCSIRSTI ");
3144 SPRINTF("PHASEMIS ");
3146 SPRINTF("BUSFREE ");
3148 SPRINTF("SCSIPERR ");
3150 SPRINTF("PHASECHG ");
3152 SPRINTF("REQINIT ");
3155 SPRINTF("SXFRCTL0( ");
3157 s = GETPORT(SXFRCTL0);
3165 SPRINTF("CLRSTCNT ");
3172 SPRINTF("SIGNAL( ");
3174 s = GETPORT(SCSISIG);
3187 SPRINTF("SELID(%02x), ", GETPORT(SELID));
3189 SPRINTF("STCNT(%d), ", GETSTCNT());
3191 SPRINTF("SSTAT2( ");
3193 s = GETPORT(SSTAT2);
3195 SPRINTF("SOFFSET ");
3200 SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3202 s = GETPORT(SSTAT3);
3203 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3205 SPRINTF("SSTAT4( ");
3206 s = GETPORT(SSTAT4);
3208 SPRINTF("SYNCERR ");
3215 SPRINTF("DMACNTRL0( ");
3216 s = GETPORT(DMACNTRL0);
3217 SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3218 SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3219 SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3225 SPRINTF("RSTFIFO ");
3230 SPRINTF("DMASTAT( ");
3231 s = GETPORT(DMASTAT);
3235 SPRINTF("WORDRDY ");
3237 SPRINTF("DFIFOFULL ");
3239 SPRINTF("DFIFOEMP ");
3242 SPRINTF("enabled interrupts( ");
3244 s = GETPORT(SIMODE0);
3246 SPRINTF("ENSELDO ");
3248 SPRINTF("ENSELDI ");
3250 SPRINTF("ENSELINGO ");
3252 SPRINTF("ENSWRAP ");
3254 SPRINTF("ENSDONE ");
3256 SPRINTF("ENSPIORDY ");
3258 SPRINTF("ENDMADONE ");
3260 s = GETPORT(SIMODE1);
3262 SPRINTF("ENSELTIMO ");
3264 SPRINTF("ENATNTARG ");
3266 SPRINTF("ENPHASEMIS ");
3268 SPRINTF("ENBUSFREE ");
3270 SPRINTF("ENSCSIPERR ");
3272 SPRINTF("ENPHASECHG ");
3274 SPRINTF("ENREQINIT ");
3277 return (pos - start);
3280 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3282 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3285 #if defined(AHA152X_DEBUG)
3286 if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3287 int debug = HOSTDATA(shpnt)->debug;
3289 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3291 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3294 #if defined(AHA152X_STAT)
3295 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3298 HOSTDATA(shpnt)->total_commands=0;
3299 HOSTDATA(shpnt)->disconnections=0;
3300 HOSTDATA(shpnt)->busfree_without_any_action=0;
3301 HOSTDATA(shpnt)->busfree_without_old_command=0;
3302 HOSTDATA(shpnt)->busfree_without_new_command=0;
3303 HOSTDATA(shpnt)->busfree_without_done_command=0;
3304 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3305 for (i = idle; i<maxstate; i++) {
3306 HOSTDATA(shpnt)->count[i]=0;
3307 HOSTDATA(shpnt)->count_trans[i]=0;
3308 HOSTDATA(shpnt)->time[i]=0;
3311 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3324 #define SPRINTF(args...) \
3325 do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3327 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3328 off_t offset, int length, int inout)
3333 unsigned long flags;
3336 DPRINTK(debug_procinfo,
3337 KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3338 buffer, offset, length, shpnt->host_no, inout);
3342 return aha152x_set_info(buffer, length, shpnt);
3344 SPRINTF(AHA152X_REVID "\n");
3346 SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3347 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3348 SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3349 SPRINTF("disconnection/reconnection %s\n",
3350 RECONNECT ? "enabled" : "disabled");
3351 SPRINTF("parity checking %s\n",
3352 PARITY ? "enabled" : "disabled");
3353 SPRINTF("synchronous transfers %s\n",
3354 SYNCHRONOUS ? "enabled" : "disabled");
3355 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3358 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3359 for (i = 0; i < 8; i++)
3360 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3361 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3363 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3364 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3365 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3367 #if defined(AHA152X_DEBUG)
3368 #define PDEBUG(flags,txt) \
3369 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3371 SPRINTF("enabled debugging options: ");
3373 PDEBUG(debug_procinfo, "procinfo");
3374 PDEBUG(debug_queue, "queue");
3375 PDEBUG(debug_intr, "interrupt");
3376 PDEBUG(debug_selection, "selection");
3377 PDEBUG(debug_msgo, "message out");
3378 PDEBUG(debug_msgi, "message in");
3379 PDEBUG(debug_status, "status");
3380 PDEBUG(debug_cmd, "command");
3381 PDEBUG(debug_datai, "data in");
3382 PDEBUG(debug_datao, "data out");
3383 PDEBUG(debug_eh, "eh");
3384 PDEBUG(debug_locks, "locks");
3385 PDEBUG(debug_phases, "phases");
3390 SPRINTF("\nqueue status:\n");
3393 SPRINTF("not yet issued commands:\n");
3394 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3395 pos += get_command(pos, ptr);
3397 SPRINTF("no not yet issued commands\n");
3401 SPRINTF("current command:\n");
3402 pos += get_command(pos, CURRENT_SC);
3404 SPRINTF("no current command\n");
3406 if (DISCONNECTED_SC) {
3407 SPRINTF("disconnected commands:\n");
3408 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3409 pos += get_command(pos, ptr);
3411 SPRINTF("no disconnected commands\n");
3413 pos += get_ports(shpnt, pos);
3415 #if defined(AHA152X_STAT)
3416 SPRINTF("statistics:\n"
3417 "total commands: %d\n"
3418 "disconnections: %d\n"
3419 "busfree with check condition: %d\n"
3420 "busfree without old command: %d\n"
3421 "busfree without new command: %d\n"
3422 "busfree without done command: %d\n"
3423 "busfree without any action: %d\n"
3428 HOSTDATA(shpnt)->total_commands,
3429 HOSTDATA(shpnt)->disconnections,
3430 HOSTDATA(shpnt)->busfree_with_check_condition,
3431 HOSTDATA(shpnt)->busfree_without_old_command,
3432 HOSTDATA(shpnt)->busfree_without_new_command,
3433 HOSTDATA(shpnt)->busfree_without_done_command,
3434 HOSTDATA(shpnt)->busfree_without_any_action);
3435 for(i=0; i<maxstate; i++) {
3436 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3438 HOSTDATA(shpnt)->count_trans[i],
3439 HOSTDATA(shpnt)->count[i],
3440 HOSTDATA(shpnt)->time[i]);
3444 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3446 thislength = pos - (buffer + offset);
3447 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3450 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3455 thislength = thislength<length ? thislength : length;
3457 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3459 *start = buffer + offset;
3460 return thislength < length ? thislength : length;
3463 static struct scsi_host_template aha152x_driver_template = {
3464 .module = THIS_MODULE,
3465 .name = AHA152X_REVID,
3466 .proc_name = "aha152x",
3467 .proc_info = aha152x_proc_info,
3468 .queuecommand = aha152x_queue,
3469 .eh_abort_handler = aha152x_abort,
3470 .eh_device_reset_handler = aha152x_device_reset,
3471 .eh_bus_reset_handler = aha152x_bus_reset,
3472 .eh_host_reset_handler = aha152x_host_reset,
3473 .bios_param = aha152x_biosparam,
3476 .sg_tablesize = SG_ALL,
3478 .use_clustering = DISABLE_CLUSTERING,
3481 #if !defined(PCMCIA)
3482 static int setup_count;
3483 static struct aha152x_setup setup[2];
3485 /* possible i/o addresses for the AIC-6260; default first */
3486 static unsigned short ports[] = { 0x340, 0x140 };
3488 #if !defined(SKIP_BIOSTEST)
3489 /* possible locations for the Adaptec BIOS; defaults first */
3490 static unsigned int addresses[] =
3492 0xdc000, /* default first */
3499 0xeb800, /* VTech Platinum SMP */
3503 /* signatures for various AIC-6[23]60 based controllers.
3504 The point in detecting signatures is to avoid useless and maybe
3505 harmful probes on ports. I'm not sure that all listed boards pass
3506 auto-configuration. For those which fail the BIOS signature is
3507 obsolete, because user intervention to supply the configuration is
3508 needed anyway. May be an information whether or not the BIOS supports
3509 extended translation could be also useful here. */
3510 static struct signature {
3511 unsigned char *signature;
3516 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3518 { "Adaptec AHA-1520B", 0x000b, 17 },
3519 /* Adaptec 152x rev B */
3520 { "Adaptec AHA-1520B", 0x0026, 17 },
3521 /* Iomega Jaz Jet ISA (AIC6370Q) */
3522 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3523 /* on-board controller */
3524 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3525 /* on-board controller */
3526 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3527 /* on-board controller */
3528 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3529 /* on-board controller */
3530 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3531 /* ScsiPro-Controller */
3532 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3533 /* Gigabyte Local-Bus-SCSI */
3534 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3536 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3537 /* IBM Thinkpad Dock II */
3538 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3539 /* IBM Thinkpad Dock II SCSI */
3540 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3541 /* DTC 3520A ISA SCSI */
3543 #endif /* !SKIP_BIOSTEST */
3546 * Test, if port_base is valid.
3549 static int aha152x_porttest(int io_port)
3553 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3554 for (i = 0; i < 16; i++)
3555 SETPORT(io_port + O_STACK, i);
3557 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3558 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3564 static int tc1550_porttest(int io_port)
3568 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3569 for (i = 0; i < 16; i++)
3570 SETPORT(io_port + O_STACK, i);
3572 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3573 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3580 static int checksetup(struct aha152x_setup *setup)
3583 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3586 if (i == ARRAY_SIZE(ports))
3589 if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) {
3590 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3594 if( aha152x_porttest(setup->io_port) ) {
3596 } else if( tc1550_porttest(setup->io_port) ) {
3599 release_region(setup->io_port, IO_RANGE);
3603 release_region(setup->io_port, IO_RANGE);
3605 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3608 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3611 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3614 if ((setup->parity < 0) || (setup->parity > 1))
3617 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3620 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3628 static int __init aha152x_init(void)
3631 #if defined(AUTOCONF)
3632 aha152x_config conf;
3635 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3638 if ( setup_count ) {
3639 printk(KERN_INFO "aha152x: processing commandline: ");
3641 for (i = 0; i<setup_count; i++) {
3642 if (!checksetup(&setup[i])) {
3643 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3644 printk(KERN_ERR "aha152x: invalid line\n");
3651 if (setup_count < ARRAY_SIZE(setup)) {
3652 struct aha152x_setup override = SETUP0;
3654 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3655 if (!checksetup(&override)) {
3656 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3662 override.synchronous,
3664 override.ext_trans);
3666 setup[setup_count++] = override;
3672 if (setup_count < ARRAY_SIZE(setup)) {
3673 struct aha152x_setup override = SETUP1;
3675 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3676 if (!checksetup(&override)) {
3677 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3683 override.synchronous,
3685 override.ext_trans);
3687 setup[setup_count++] = override;
3693 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3695 setup[setup_count].conf = "";
3696 setup[setup_count].io_port = aha152x[0];
3697 setup[setup_count].irq = aha152x[1];
3698 setup[setup_count].scsiid = aha152x[2];
3699 setup[setup_count].reconnect = aha152x[3];
3700 setup[setup_count].parity = aha152x[4];
3701 setup[setup_count].synchronous = aha152x[5];
3702 setup[setup_count].delay = aha152x[6];
3703 setup[setup_count].ext_trans = aha152x[7];
3704 #if defined(AHA152X_DEBUG)
3705 setup[setup_count].debug = aha152x[8];
3707 } else if(io[0]!=0 || irq[0]!=0) {
3708 if(io[0]!=0) setup[setup_count].io_port = io[0];
3709 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3711 setup[setup_count].scsiid = scsiid[0];
3712 setup[setup_count].reconnect = reconnect[0];
3713 setup[setup_count].parity = parity[0];
3714 setup[setup_count].synchronous = sync[0];
3715 setup[setup_count].delay = delay[0];
3716 setup[setup_count].ext_trans = exttrans[0];
3717 #if defined(AHA152X_DEBUG)
3718 setup[setup_count].debug = debug[0];
3722 if (checksetup(&setup[setup_count]))
3725 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",
3726 setup[setup_count].io_port,
3727 setup[setup_count].irq,
3728 setup[setup_count].scsiid,
3729 setup[setup_count].reconnect,
3730 setup[setup_count].parity,
3731 setup[setup_count].synchronous,
3732 setup[setup_count].delay,
3733 setup[setup_count].ext_trans);
3736 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3737 if(aha152x1[0]!=0) {
3738 setup[setup_count].conf = "";
3739 setup[setup_count].io_port = aha152x1[0];
3740 setup[setup_count].irq = aha152x1[1];
3741 setup[setup_count].scsiid = aha152x1[2];
3742 setup[setup_count].reconnect = aha152x1[3];
3743 setup[setup_count].parity = aha152x1[4];
3744 setup[setup_count].synchronous = aha152x1[5];
3745 setup[setup_count].delay = aha152x1[6];
3746 setup[setup_count].ext_trans = aha152x1[7];
3747 #if defined(AHA152X_DEBUG)
3748 setup[setup_count].debug = aha152x1[8];
3750 } else if(io[1]!=0 || irq[1]!=0) {
3751 if(io[1]!=0) setup[setup_count].io_port = io[1];
3752 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3754 setup[setup_count].scsiid = scsiid[1];
3755 setup[setup_count].reconnect = reconnect[1];
3756 setup[setup_count].parity = parity[1];
3757 setup[setup_count].synchronous = sync[1];
3758 setup[setup_count].delay = delay[1];
3759 setup[setup_count].ext_trans = exttrans[1];
3760 #if defined(AHA152X_DEBUG)
3761 setup[setup_count].debug = debug[1];
3764 if (checksetup(&setup[setup_count]))
3767 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",
3768 setup[setup_count].io_port,
3769 setup[setup_count].irq,
3770 setup[setup_count].scsiid,
3771 setup[setup_count].reconnect,
3772 setup[setup_count].parity,
3773 setup[setup_count].synchronous,
3774 setup[setup_count].delay,
3775 setup[setup_count].ext_trans);
3780 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3781 while ( setup_count<ARRAY_SIZE(setup) &&
3782 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3783 if (pnp_device_attach(dev) < 0)
3786 if (pnp_activate_dev(dev) < 0) {
3787 pnp_device_detach(dev);
3791 if (!pnp_port_valid(dev, 0)) {
3792 pnp_device_detach(dev);
3796 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3797 pnp_device_detach(dev);
3801 setup[setup_count].io_port = pnp_port_start(dev, 0);
3802 setup[setup_count].irq = pnp_irq(dev, 0);
3803 setup[setup_count].scsiid = 7;
3804 setup[setup_count].reconnect = 1;
3805 setup[setup_count].parity = 1;
3806 setup[setup_count].synchronous = 1;
3807 setup[setup_count].delay = DELAY_DEFAULT;
3808 setup[setup_count].ext_trans = 0;
3809 #if defined(AHA152X_DEBUG)
3810 setup[setup_count].debug = DEBUG_DEFAULT;
3812 #if defined(__ISAPNP__)
3813 pnpdev[setup_count] = dev;
3816 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3817 setup[setup_count].io_port, setup[setup_count].irq);
3823 #if defined(AUTOCONF)
3824 if (setup_count<ARRAY_SIZE(setup)) {
3825 #if !defined(SKIP_BIOSTEST)
3827 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3828 void __iomem *p = ioremap(addresses[i], 0x4000);
3831 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3832 ok = check_signature(p + signatures[j].sig_offset,
3833 signatures[j].signature, signatures[j].sig_length);
3836 if (!ok && setup_count == 0)
3839 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3841 printk(KERN_INFO "aha152x: ");
3842 #endif /* !SKIP_BIOSTEST */
3845 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3846 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3849 if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) {
3850 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3854 if (aha152x_porttest(ports[i])) {
3855 setup[setup_count].tc1550 = 0;
3858 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3859 } else if (tc1550_porttest(ports[i])) {
3860 setup[setup_count].tc1550 = 1;
3863 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3865 release_region(ports[i], IO_RANGE);
3869 release_region(ports[i], IO_RANGE);
3872 setup[setup_count].io_port = ports[i];
3873 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3874 setup[setup_count].scsiid = conf.cf_id;
3875 setup[setup_count].reconnect = conf.cf_tardisc;
3876 setup[setup_count].parity = !conf.cf_parity;
3877 setup[setup_count].synchronous = conf.cf_syncneg;
3878 setup[setup_count].delay = DELAY_DEFAULT;
3879 setup[setup_count].ext_trans = 0;
3880 #if defined(AHA152X_DEBUG)
3881 setup[setup_count].debug = DEBUG_DEFAULT;
3888 printk("auto configuration: ok, ");
3892 printk("%d controller(s) configured\n", setup_count);
3894 for (i=0; i<setup_count; i++) {
3895 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3896 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3899 release_region(setup[i].io_port, IO_RANGE);
3900 #if defined(__ISAPNP__)
3901 } else if( pnpdev[i] ) {
3902 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3907 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3910 #if defined(__ISAPNP__)
3912 pnp_device_detach(pnpdev[i]);
3916 return registered_count>0;
3919 static void __exit aha152x_exit(void)
3923 for(i=0; i<ARRAY_SIZE(setup); i++) {
3924 aha152x_release(aha152x_host[i]);
3925 aha152x_host[i]=NULL;
3929 module_init(aha152x_init);
3930 module_exit(aha152x_exit);
3932 #if !defined(MODULE)
3933 static int __init aha152x_setup(char *str)
3935 #if defined(AHA152X_DEBUG)
3940 get_options(str, ARRAY_SIZE(ints), ints);
3942 if(setup_count>=ARRAY_SIZE(setup)) {
3943 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3947 setup[setup_count].conf = str;
3948 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3949 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3950 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3951 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3952 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3953 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3954 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3955 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3956 #if defined(AHA152X_DEBUG)
3957 setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3959 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3960 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3962 if (ints[0] > 8) { /*}*/
3963 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3964 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3973 __setup("aha152x=", aha152x_setup);
3976 #endif /* !PCMCIA */