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>
240 #include <linux/io.h>
241 #include <linux/blkdev.h>
242 #include <asm/system.h>
243 #include <linux/completion.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 <linux/list.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>
263 #include <scsi/scsi_eh.h>
266 static LIST_HEAD(aha152x_host_list);
271 /* For PCMCIA cards, always use AUTOCONF */
272 #if defined(PCMCIA) || defined(MODULE)
273 #if !defined(AUTOCONF)
278 #if !defined(AUTOCONF) && !defined(SETUP0)
279 #error define AUTOCONF or SETUP0
282 #if defined(AHA152X_DEBUG)
283 #define DEBUG_DEFAULT debug_eh
285 #define DPRINTK(when,msgs...) \
286 do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
288 #define DO_LOCK(flags) \
290 if(spin_is_locked(&QLOCK)) { \
291 DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
293 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
294 spin_lock_irqsave(&QLOCK,flags); \
295 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
296 QLOCKER=__FUNCTION__; \
300 #define DO_UNLOCK(flags) \
302 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
303 spin_unlock_irqrestore(&QLOCK,flags); \
304 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
305 QLOCKER="(not locked)"; \
310 #define DPRINTK(when,msgs...)
311 #define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
312 #define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
315 #define LEAD "(scsi%d:%d:%d) "
316 #define WARN_LEAD KERN_WARNING LEAD
317 #define INFO_LEAD KERN_INFO LEAD
318 #define NOTE_LEAD KERN_NOTICE LEAD
319 #define ERR_LEAD KERN_ERR LEAD
320 #define DEBUG_LEAD KERN_DEBUG LEAD
321 #define CMDINFO(cmd) \
322 (cmd) ? ((cmd)->device->host->host_no) : -1, \
323 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
324 (cmd) ? ((cmd)->device->lun & 0x07) : -1
327 CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
329 scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
332 #define DELAY_DEFAULT 1000
340 #define IRQ_MAX (NR_IRQS-1)
347 not_issued = 0x0001, /* command not yet issued */
348 selecting = 0x0002, /* target is beeing selected */
349 identified = 0x0004, /* IDENTIFY was sent */
350 disconnected = 0x0008, /* target disconnected */
351 completed = 0x0010, /* target sent COMMAND COMPLETE */
352 aborted = 0x0020, /* ABORT was sent */
353 resetted = 0x0040, /* BUS DEVICE RESET was sent */
354 spiordy = 0x0080, /* waiting for SPIORDY to raise */
355 syncneg = 0x0100, /* synchronous negotiation in progress */
356 aborting = 0x0200, /* ABORT is pending */
357 resetting = 0x0400, /* BUS DEVICE RESET is pending */
358 check_condition = 0x0800, /* requesting sense after CHECK CONDITION */
361 MODULE_AUTHOR("Jürgen Fischer");
362 MODULE_DESCRIPTION(AHA152X_REVID);
363 MODULE_LICENSE("GPL");
367 static int io[] = {0, 0};
368 module_param_array(io, int, NULL, 0);
369 MODULE_PARM_DESC(io,"base io address of controller");
371 static int irq[] = {0, 0};
372 module_param_array(irq, int, NULL, 0);
373 MODULE_PARM_DESC(irq,"interrupt for controller");
375 static int scsiid[] = {7, 7};
376 module_param_array(scsiid, int, NULL, 0);
377 MODULE_PARM_DESC(scsiid,"scsi id of controller");
379 static int reconnect[] = {1, 1};
380 module_param_array(reconnect, int, NULL, 0);
381 MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
383 static int parity[] = {1, 1};
384 module_param_array(parity, int, NULL, 0);
385 MODULE_PARM_DESC(parity,"use scsi parity");
387 static int sync[] = {1, 1};
388 module_param_array(sync, int, NULL, 0);
389 MODULE_PARM_DESC(sync,"use synchronous transfers");
391 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
392 module_param_array(delay, int, NULL, 0);
393 MODULE_PARM_DESC(delay,"scsi reset delay");
395 static int exttrans[] = {0, 0};
396 module_param_array(exttrans, int, NULL, 0);
397 MODULE_PARM_DESC(exttrans,"use extended translation");
399 #if !defined(AHA152X_DEBUG)
400 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
401 module_param_array(aha152x, int, NULL, 0);
402 MODULE_PARM_DESC(aha152x, "parameters for first controller");
404 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
405 module_param_array(aha152x1, int, NULL, 0);
406 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
408 static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
409 module_param_array(debug, int, NULL, 0);
410 MODULE_PARM_DESC(debug, "flags for driver debugging");
412 static int aha152x[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
413 module_param_array(aha152x, int, NULL, 0);
414 MODULE_PARM_DESC(aha152x, "parameters for first controller");
416 static int aha152x1[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
417 module_param_array(aha152x1, int, NULL, 0);
418 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
419 #endif /* !defined(AHA152X_DEBUG) */
423 static struct isapnp_device_id id_table[] __devinitdata = {
424 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
425 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1505), 0 },
426 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
427 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1530), 0 },
428 { ISAPNP_DEVICE_SINGLE_END, }
430 MODULE_DEVICE_TABLE(isapnp, id_table);
435 static struct scsi_host_template aha152x_driver_template;
438 * internal states of the host
460 * current state information of the host
463 struct aha152x_hostdata {
465 /* pending commands to issue */
467 Scsi_Cmnd *current_SC;
468 /* current command on the bus */
470 Scsi_Cmnd *disconnected_SC;
471 /* commands that disconnected */
474 /* command that was completed */
479 #if defined(AHA152X_DEBUG)
481 /* which function has the lock */
482 int lockerl; /* where did it get it */
484 int debug; /* current debugging setting */
487 #if defined(AHA152X_STAT)
490 int busfree_without_any_action;
491 int busfree_without_old_command;
492 int busfree_without_new_command;
493 int busfree_without_done_command;
494 int busfree_with_check_condition;
496 int count_trans[maxstate];
497 unsigned long time[maxstate];
500 int commands; /* current number of commands */
502 int reconnect; /* disconnection allowed */
503 int parity; /* parity checking enabled */
504 int synchronous; /* synchronous transferes enabled */
505 int delay; /* reset out delay */
506 int ext_trans; /* extended translation enabled */
508 int swint; /* software-interrupt was fired during detect() */
509 int service; /* bh needs to be run */
510 int in_intr; /* bh is running */
514 last state different from current state */
515 enum aha152x_state state, prevstate, laststate;
518 /* reconnecting target */
520 unsigned char syncrate[8];
521 /* current synchronous transfer agreements */
523 unsigned char syncneg[8];
524 /* 0: no negotiation;
525 * 1: negotiation in progress;
526 * 2: negotiation completed
530 /* number of sent bytes of current command */
533 /* number of received message bytes */
534 unsigned char msgi[256];
535 /* received message bytes */
537 int msgo_i, msgo_len;
538 /* number of sent bytes and length of current messages */
539 unsigned char msgo[256];
540 /* pending messages */
543 /* number of sent/received bytes in dataphase */
545 unsigned long io_port0;
546 unsigned long io_port1;
549 struct pnp_dev *pnpdev;
551 struct list_head host_list;
556 * host specific command extension
559 struct aha152x_scdata {
560 Scsi_Cmnd *next; /* next sc in queue */
561 struct completion *done;/* semaphore to block on */
562 struct scsi_eh_save ses;
565 /* access macros for hostdata */
567 #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
569 #define HOSTNO ((shpnt)->host_no)
571 #define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
572 #define DONE_SC (HOSTDATA(shpnt)->done_SC)
573 #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
574 #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
575 #define QLOCK (HOSTDATA(shpnt)->lock)
576 #define QLOCKER (HOSTDATA(shpnt)->locker)
577 #define QLOCKERL (HOSTDATA(shpnt)->lockerl)
579 #define STATE (HOSTDATA(shpnt)->state)
580 #define PREVSTATE (HOSTDATA(shpnt)->prevstate)
581 #define LASTSTATE (HOSTDATA(shpnt)->laststate)
583 #define RECONN_TARGET (HOSTDATA(shpnt)->target)
585 #define CMD_I (HOSTDATA(shpnt)->cmd_i)
587 #define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
588 #define MSGO_I (HOSTDATA(shpnt)->msgo_i)
589 #define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
590 #define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
592 #define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
593 #define MSGILEN (HOSTDATA(shpnt)->msgi_len)
594 #define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
596 #define DATA_LEN (HOSTDATA(shpnt)->data_len)
598 #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
599 #define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
601 #define DELAY (HOSTDATA(shpnt)->delay)
602 #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
603 #define TC1550 (HOSTDATA(shpnt)->tc1550)
604 #define RECONNECT (HOSTDATA(shpnt)->reconnect)
605 #define PARITY (HOSTDATA(shpnt)->parity)
606 #define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
608 #define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
609 #define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
611 #define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
612 #define SCNEXT(SCpnt) SCDATA(SCpnt)->next
613 #define SCSEM(SCpnt) SCDATA(SCpnt)->done
615 #define SG_ADDRESS(buffer) ((char *) sg_virt((buffer)))
618 static void seldi_run(struct Scsi_Host *shpnt);
619 static void seldo_run(struct Scsi_Host *shpnt);
620 static void selto_run(struct Scsi_Host *shpnt);
621 static void busfree_run(struct Scsi_Host *shpnt);
623 static void msgo_init(struct Scsi_Host *shpnt);
624 static void msgo_run(struct Scsi_Host *shpnt);
625 static void msgo_end(struct Scsi_Host *shpnt);
627 static void cmd_init(struct Scsi_Host *shpnt);
628 static void cmd_run(struct Scsi_Host *shpnt);
629 static void cmd_end(struct Scsi_Host *shpnt);
631 static void datai_init(struct Scsi_Host *shpnt);
632 static void datai_run(struct Scsi_Host *shpnt);
633 static void datai_end(struct Scsi_Host *shpnt);
635 static void datao_init(struct Scsi_Host *shpnt);
636 static void datao_run(struct Scsi_Host *shpnt);
637 static void datao_end(struct Scsi_Host *shpnt);
639 static void status_run(struct Scsi_Host *shpnt);
641 static void msgi_run(struct Scsi_Host *shpnt);
642 static void msgi_end(struct Scsi_Host *shpnt);
644 static void parerr_run(struct Scsi_Host *shpnt);
645 static void rsti_run(struct Scsi_Host *shpnt);
647 static void is_complete(struct Scsi_Host *shpnt);
655 void (*init)(struct Scsi_Host *);
656 void (*run)(struct Scsi_Host *);
657 void (*end)(struct Scsi_Host *);
660 { "idle", NULL, NULL, NULL, 0},
661 { "unknown", NULL, NULL, NULL, 0},
662 { "seldo", NULL, seldo_run, NULL, 0},
663 { "seldi", NULL, seldi_run, NULL, 0},
664 { "selto", NULL, selto_run, NULL, 0},
665 { "busfree", NULL, busfree_run, NULL, 0},
666 { "msgo", msgo_init, msgo_run, msgo_end, 1},
667 { "cmd", cmd_init, cmd_run, cmd_end, 1},
668 { "msgi", NULL, msgi_run, msgi_end, 1},
669 { "status", NULL, status_run, NULL, 1},
670 { "datai", datai_init, datai_run, datai_end, 0},
671 { "datao", datao_init, datao_run, datao_end, 0},
672 { "parerr", NULL, parerr_run, NULL, 0},
673 { "rsti", NULL, rsti_run, NULL, 0},
676 /* setup & interrupt */
677 static irqreturn_t intr(int irq, void *dev_id);
678 static void reset_ports(struct Scsi_Host *shpnt);
679 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
680 static void done(struct Scsi_Host *shpnt, int error);
683 static void disp_ports(struct Scsi_Host *shpnt);
684 static void show_command(Scsi_Cmnd * ptr);
685 static void show_queues(struct Scsi_Host *shpnt);
686 static void disp_enintr(struct Scsi_Host *shpnt);
693 static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
697 SCNEXT(new_SC) = NULL;
701 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
703 SCNEXT(end) = new_SC;
707 static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
719 static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
721 Scsi_Cmnd *ptr, *prev;
723 for (ptr = *SC, prev = NULL;
724 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
725 prev = ptr, ptr = SCNEXT(ptr))
730 SCNEXT(prev) = SCNEXT(ptr);
740 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
742 Scsi_Cmnd *ptr, *prev;
744 for (ptr = *SC, prev = NULL;
746 prev = ptr, ptr = SCNEXT(ptr))
751 SCNEXT(prev) = SCNEXT(ptr);
761 static irqreturn_t swintr(int irqno, void *dev_id)
763 struct Scsi_Host *shpnt = dev_id;
765 HOSTDATA(shpnt)->swint++;
767 SETPORT(DMACNTRL0, INTEN);
771 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
773 struct Scsi_Host *shpnt;
775 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
777 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
781 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
782 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
784 /* need to have host registered before triggering any interrupt */
785 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
787 shpnt->io_port = setup->io_port;
788 shpnt->n_io_port = IO_RANGE;
789 shpnt->irq = setup->irq;
791 if (!setup->tc1550) {
792 HOSTIOPORT0 = setup->io_port;
793 HOSTIOPORT1 = setup->io_port;
795 HOSTIOPORT0 = setup->io_port+0x10;
796 HOSTIOPORT1 = setup->io_port-0x10;
799 spin_lock_init(&QLOCK);
800 RECONNECT = setup->reconnect;
801 SYNCHRONOUS = setup->synchronous;
802 PARITY = setup->parity;
803 DELAY = setup->delay;
804 EXT_TRANS = setup->ext_trans;
806 #if defined(AHA152X_DEBUG)
807 HOSTDATA(shpnt)->debug = setup->debug;
810 SETPORT(SCSIID, setup->scsiid << 4);
811 shpnt->this_id = setup->scsiid;
813 if (setup->reconnect)
814 shpnt->can_queue = AHA152X_MAXQUEUE;
817 printk("aha152x: resetting bus...\n");
818 SETPORT(SCSISEQ, SCSIRSTO);
827 "vital data: rev=%x, "
828 "io=0x%03lx (0x%03lx/0x%03lx), "
835 "extended translation=%s\n",
836 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
838 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
841 RECONNECT ? "enabled" : "disabled",
842 PARITY ? "enabled" : "disabled",
843 SYNCHRONOUS ? "enabled" : "disabled",
845 EXT_TRANS ? "enabled" : "disabled");
847 /* not expecting any interrupts */
851 if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
852 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
856 HOSTDATA(shpnt)->swint = 0;
858 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
861 SETPORT(DMACNTRL0, SWINT|INTEN);
863 free_irq(shpnt->irq, shpnt);
865 if (!HOSTDATA(shpnt)->swint) {
866 if (TESTHI(DMASTAT, INTSTAT)) {
872 SETPORT(DMACNTRL0, INTEN);
874 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
875 "Please verify.\n", shpnt->host_no, shpnt->irq);
881 /* clear interrupts */
882 SETPORT(SSTAT0, 0x7f);
883 SETPORT(SSTAT1, 0xef);
885 if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
886 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
890 if( scsi_add_host(shpnt, NULL) ) {
891 free_irq(shpnt->irq, shpnt);
892 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
896 scsi_scan_host(shpnt);
901 list_del(&HOSTDATA(shpnt)->host_list);
902 scsi_host_put(shpnt);
907 void aha152x_release(struct Scsi_Host *shpnt)
912 scsi_remove_host(shpnt);
914 free_irq(shpnt->irq, shpnt);
918 release_region(shpnt->io_port, IO_RANGE);
922 if (HOSTDATA(shpnt)->pnpdev)
923 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
926 list_del(&HOSTDATA(shpnt)->host_list);
927 scsi_host_put(shpnt);
932 * setup controller to generate interrupts depending
933 * on current state (lock has to be acquired)
936 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
939 CURRENT_SC->SCp.phase |= 1 << 16;
941 if(CURRENT_SC->SCp.phase & selecting) {
942 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
943 SETPORT(SSTAT1, SELTO);
944 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
945 SETPORT(SIMODE1, ENSELTIMO);
947 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
948 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
949 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
951 } else if(STATE==seldi) {
952 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
954 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
956 DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
958 DISCONNECTED_SC ? "(reselection)" : "",
959 ISSUE_SC ? "(busfree)" : "");
960 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
961 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
964 if(!HOSTDATA(shpnt)->in_intr)
965 SETBITS(DMACNTRL0, INTEN);
967 return TESTHI(DMASTAT, INTSTAT);
972 * Queue a command and setup interrupts for a free bus.
974 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
975 int phase, void (*done)(Scsi_Cmnd *))
977 struct Scsi_Host *shpnt = SCpnt->device->host;
980 #if defined(AHA152X_DEBUG)
981 if (HOSTDATA(shpnt)->debug & debug_queue) {
982 printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
983 CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len,
984 scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
985 __scsi_print_command(SCpnt->cmnd);
989 SCpnt->scsi_done = done;
990 SCpnt->SCp.phase = not_issued | phase;
991 SCpnt->SCp.Status = 0x1; /* Ilegal status by SCSI standard */
992 SCpnt->SCp.Message = 0;
993 SCpnt->SCp.have_data_in = 0;
994 SCpnt->SCp.sent_command = 0;
996 if(SCpnt->SCp.phase & (resetting|check_condition)) {
997 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
998 printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1002 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1003 if(!SCpnt->host_scribble) {
1004 printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1009 SCNEXT(SCpnt) = NULL;
1010 SCSEM(SCpnt) = complete;
1012 /* setup scratch area
1013 SCp.ptr : buffer pointer
1014 SCp.this_residual : buffer length
1015 SCp.buffer : next buffer
1016 SCp.buffers_residual : left buffers in list
1017 SCp.phase : current state of the command */
1019 if ((phase & resetting) || !scsi_sglist(SCpnt)) {
1020 SCpnt->SCp.ptr = NULL;
1021 SCpnt->SCp.this_residual = 0;
1022 scsi_set_resid(SCpnt, 0);
1023 SCpnt->SCp.buffer = NULL;
1024 SCpnt->SCp.buffers_residual = 0;
1026 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1027 SCpnt->SCp.buffer = scsi_sglist(SCpnt);
1028 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
1029 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
1030 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
1035 #if defined(AHA152X_STAT)
1036 HOSTDATA(shpnt)->total_commands++;
1039 /* Turn led on, when this is the first command. */
1040 HOSTDATA(shpnt)->commands++;
1041 if (HOSTDATA(shpnt)->commands==1)
1044 append_SC(&ISSUE_SC, SCpnt);
1046 if(!HOSTDATA(shpnt)->in_intr)
1047 setup_expected_interrupts(shpnt);
1058 static int aha152x_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1061 if(*SCpnt->cmnd == REQUEST_SENSE) {
1069 return aha152x_internal_queue(SCpnt, NULL, 0, done);
1077 static void reset_done(Scsi_Cmnd *SCpnt)
1080 struct Scsi_Host *shpnt = SCpnt->host;
1081 DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1084 complete(SCSEM(SCpnt));
1086 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1094 static int aha152x_abort(Scsi_Cmnd *SCpnt)
1096 struct Scsi_Host *shpnt = SCpnt->device->host;
1098 unsigned long flags;
1100 #if defined(AHA152X_DEBUG)
1101 if(HOSTDATA(shpnt)->debug & debug_eh) {
1102 printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1109 ptr=remove_SC(&ISSUE_SC, SCpnt);
1112 DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1114 HOSTDATA(shpnt)->commands--;
1115 if (!HOSTDATA(shpnt)->commands)
1119 kfree(SCpnt->host_scribble);
1120 SCpnt->host_scribble=NULL;
1129 * for current command: queue ABORT for message out and raise ATN
1130 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1134 printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1143 static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1145 struct Scsi_Host *shpnt = SCpnt->device->host;
1146 DECLARE_COMPLETION(done);
1147 int ret, issued, disconnected;
1148 unsigned char old_cmd_len = SCpnt->cmd_len;
1149 unsigned long flags;
1150 unsigned long timeleft;
1152 #if defined(AHA152X_DEBUG)
1153 if(HOSTDATA(shpnt)->debug & debug_eh) {
1154 printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1159 if(CURRENT_SC==SCpnt) {
1160 printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1165 issued = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1166 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1171 aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1173 timeleft = wait_for_completion_timeout(&done, 100*HZ);
1175 /* remove command from issue queue */
1177 remove_SC(&ISSUE_SC, SCpnt);
1181 SCpnt->cmd_len = old_cmd_len;
1185 if(SCpnt->SCp.phase & resetted) {
1186 HOSTDATA(shpnt)->commands--;
1187 if (!HOSTDATA(shpnt)->commands)
1189 kfree(SCpnt->host_scribble);
1190 SCpnt->host_scribble=NULL;
1196 append_SC(&ISSUE_SC, SCpnt);
1197 } else if(disconnected) {
1198 append_SC(&DISCONNECTED_SC, SCpnt);
1208 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1219 printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1223 if (!ptr->device->soft_reset) {
1224 DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1225 remove_SC(SCs, ptr);
1226 HOSTDATA(shpnt)->commands--;
1227 kfree(ptr->host_scribble);
1228 ptr->host_scribble=NULL;
1239 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1241 unsigned long flags;
1245 #if defined(AHA152X_DEBUG)
1246 if(HOSTDATA(shpnt)->debug & debug_eh) {
1247 printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1252 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1253 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1255 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1257 SETPORT(SCSISEQ, SCSIRSTO);
1259 SETPORT(SCSISEQ, 0);
1262 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1264 setup_expected_interrupts(shpnt);
1265 if(HOSTDATA(shpnt)->commands==0)
1277 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1279 return aha152x_bus_reset_host(SCpnt->device->host);
1283 * Restore default values to the AIC-6260 registers and reset the fifos
1286 static void reset_ports(struct Scsi_Host *shpnt)
1288 unsigned long flags;
1290 /* disable interrupts */
1291 SETPORT(DMACNTRL0, RSTFIFO);
1293 SETPORT(SCSISEQ, 0);
1295 SETPORT(SXFRCTL1, 0);
1296 SETPORT(SCSISIG, 0);
1299 /* clear all interrupt conditions */
1300 SETPORT(SSTAT0, 0x7f);
1301 SETPORT(SSTAT1, 0xef);
1303 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1305 SETPORT(DMACNTRL0, 0);
1306 SETPORT(DMACNTRL1, 0);
1308 SETPORT(BRSTCNTRL, 0xf1);
1310 /* clear SCSI fifos and transfer count */
1311 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1312 SETPORT(SXFRCTL0, CH1);
1315 setup_expected_interrupts(shpnt);
1320 * Reset the host (bus and controller)
1323 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1325 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1327 aha152x_bus_reset_host(shpnt);
1329 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1336 * Reset the host (bus and controller)
1339 static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1341 return aha152x_host_reset_host(SCpnt->device->host);
1345 * Return the "logical geometry"
1348 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1349 sector_t capacity, int *info_array)
1351 struct Scsi_Host *shpnt = sdev->host;
1353 /* try default translation */
1356 info_array[2] = (unsigned long)capacity / (64 * 32);
1358 /* for disks >1GB do some guessing */
1359 if (info_array[2] >= 1024) {
1362 /* try to figure out the geometry from the partition table */
1363 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1364 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1367 "aha152x: unable to verify geometry for disk with >1GB.\n"
1368 " using extended translation.\n");
1369 info_array[0] = 255;
1371 info_array[2] = (unsigned long)capacity / (255 * 63);
1374 "aha152x: unable to verify geometry for disk with >1GB.\n"
1375 " Using default translation. Please verify yourself.\n"
1376 " Perhaps you need to enable extended translation in the driver.\n"
1377 " See Documentation/scsi/aha152x.txt for details.\n");
1380 info_array[0] = info[0];
1381 info_array[1] = info[1];
1382 info_array[2] = info[2];
1384 if (info[0] == 255 && !EXT_TRANS) {
1386 "aha152x: current partition table is using extended translation.\n"
1387 " using it also, although it's not explicitly enabled.\n");
1396 * Internal done function
1399 static void done(struct Scsi_Host *shpnt, int error)
1403 printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1405 DONE_SC = CURRENT_SC;
1407 DONE_SC->result = error;
1409 printk(KERN_ERR "aha152x: done() called outside of command\n");
1412 static struct work_struct aha152x_tq;
1415 * Run service completions on the card with interrupts enabled.
1418 static void run(struct work_struct *work)
1420 struct aha152x_hostdata *hd;
1422 list_for_each_entry(hd, &aha152x_host_list, host_list) {
1423 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1433 static irqreturn_t intr(int irqno, void *dev_id)
1435 struct Scsi_Host *shpnt = dev_id;
1436 unsigned long flags;
1437 unsigned char rev, dmacntrl0;
1440 * Read a couple of registers that are known to not be all 1's. If
1441 * we read all 1's (-1), that means that either:
1443 * a. The host adapter chip has gone bad, and we cannot control it,
1445 * b. The host adapter is a PCMCIA card that has been ejected
1447 * In either case, we cannot do anything with the host adapter at
1448 * this point in time. So just ignore the interrupt and return.
1449 * In the latter case, the interrupt might actually be meant for
1450 * someone else sharing this IRQ, and that driver will handle it.
1453 dmacntrl0 = GETPORT(DMACNTRL0);
1454 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1457 if( TESTLO(DMASTAT, INTSTAT) )
1460 /* no more interrupts from the controller, while we're busy.
1461 INTEN is restored by the BH handler */
1462 CLRBITS(DMACNTRL0, INTEN);
1465 if( HOSTDATA(shpnt)->service==0 ) {
1466 HOSTDATA(shpnt)->service=1;
1468 /* Poke the BH handler */
1469 INIT_WORK(&aha152x_tq, run);
1470 schedule_work(&aha152x_tq);
1479 * - handle completition/disconnection/error of current command
1480 * - start selection for next command (if any)
1482 static void busfree_run(struct Scsi_Host *shpnt)
1484 unsigned long flags;
1485 #if defined(AHA152X_STAT)
1489 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1490 SETPORT(SXFRCTL0, CH1);
1492 SETPORT(SSTAT1, CLRBUSFREE);
1495 #if defined(AHA152X_STAT)
1498 CURRENT_SC->SCp.phase &= ~syncneg;
1500 if(CURRENT_SC->SCp.phase & completed) {
1501 /* target sent COMMAND COMPLETE */
1502 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1504 } else if(CURRENT_SC->SCp.phase & aborted) {
1505 DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1506 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1508 } else if(CURRENT_SC->SCp.phase & resetted) {
1509 DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1510 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1512 } else if(CURRENT_SC->SCp.phase & disconnected) {
1513 /* target sent DISCONNECT */
1514 DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1515 CMDINFO(CURRENT_SC),
1516 scsi_get_resid(CURRENT_SC),
1517 scsi_bufflen(CURRENT_SC));
1518 #if defined(AHA152X_STAT)
1519 HOSTDATA(shpnt)->disconnections++;
1521 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1522 CURRENT_SC->SCp.phase |= 1 << 16;
1526 done(shpnt, DID_ERROR << 16);
1528 #if defined(AHA152X_STAT)
1530 HOSTDATA(shpnt)->busfree_without_old_command++;
1537 #if defined(AHA152X_STAT)
1541 if(DONE_SC->SCp.phase & check_condition) {
1542 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1543 struct aha152x_scdata *sc = SCDATA(cmd);
1546 if(HOSTDATA(shpnt)->debug & debug_eh) {
1547 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1548 scsi_print_sense("bh", DONE_SC);
1552 scsi_eh_restore_cmnd(cmd, &sc->ses);
1554 cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1556 HOSTDATA(shpnt)->commands--;
1557 if (!HOSTDATA(shpnt)->commands)
1558 SETPORT(PORTA, 0); /* turn led off */
1559 } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1560 #if defined(AHA152X_STAT)
1561 HOSTDATA(shpnt)->busfree_with_check_condition++;
1564 DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1567 if(!(DONE_SC->SCp.phase & not_issued)) {
1568 struct aha152x_scdata *sc;
1569 Scsi_Cmnd *ptr = DONE_SC;
1572 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1576 /* It was allocated in aha152x_internal_queue? */
1578 scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1581 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1585 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1590 if(DONE_SC && DONE_SC->scsi_done) {
1591 #if defined(AHA152X_DEBUG)
1592 int hostno=DONE_SC->device->host->host_no;
1593 int id=DONE_SC->device->id & 0xf;
1594 int lun=DONE_SC->device->lun & 0x7;
1596 Scsi_Cmnd *ptr = DONE_SC;
1599 /* turn led off, when no commands are in the driver */
1600 HOSTDATA(shpnt)->commands--;
1601 if (!HOSTDATA(shpnt)->commands)
1602 SETPORT(PORTA, 0); /* turn led off */
1604 if(ptr->scsi_done != reset_done) {
1605 kfree(ptr->host_scribble);
1606 ptr->host_scribble=NULL;
1610 DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1611 ptr->scsi_done(ptr);
1612 DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1617 #if defined(AHA152X_STAT)
1619 HOSTDATA(shpnt)->busfree_without_done_command++;
1624 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1629 #if defined(AHA152X_STAT)
1632 CURRENT_SC->SCp.phase |= selecting;
1634 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1636 /* clear selection timeout */
1637 SETPORT(SSTAT1, SELTO);
1639 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1640 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1641 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1643 #if defined(AHA152X_STAT)
1644 HOSTDATA(shpnt)->busfree_without_new_command++;
1646 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1649 #if defined(AHA152X_STAT)
1651 HOSTDATA(shpnt)->busfree_without_any_action++;
1656 * Selection done (OUT)
1657 * - queue IDENTIFY message and SDTR to selected target for message out
1658 * (ATN asserted automagically via ENAUTOATNO in busfree())
1660 static void seldo_run(struct Scsi_Host *shpnt)
1662 SETPORT(SCSISIG, 0);
1663 SETPORT(SSTAT1, CLRBUSFREE);
1664 SETPORT(SSTAT1, CLRPHASECHG);
1666 CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1668 SETPORT(SCSISEQ, 0);
1670 if (TESTLO(SSTAT0, SELDO)) {
1671 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1672 done(shpnt, DID_NO_CONNECT << 16);
1676 SETPORT(SSTAT0, CLRSELDO);
1678 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1680 if (CURRENT_SC->SCp.phase & aborting) {
1682 } else if (CURRENT_SC->SCp.phase & resetting) {
1683 ADDMSGO(BUS_DEVICE_RESET);
1684 } else if (SYNCNEG==0 && SYNCHRONOUS) {
1685 CURRENT_SC->SCp.phase |= syncneg;
1686 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1687 SYNCNEG=1; /* negotiation in progress */
1695 * - return command to mid-level with failure cause
1698 static void selto_run(struct Scsi_Host *shpnt)
1700 SETPORT(SCSISEQ, 0);
1701 SETPORT(SSTAT1, CLRSELTIMO);
1703 DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1706 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1710 CURRENT_SC->SCp.phase &= ~selecting;
1712 if (CURRENT_SC->SCp.phase & aborted) {
1713 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1714 done(shpnt, DID_ABORT << 16);
1715 } else if (TESTLO(SSTAT0, SELINGO)) {
1716 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1717 done(shpnt, DID_BUS_BUSY << 16);
1719 /* ARBITRATION won, but SELECTION failed */
1720 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1721 done(shpnt, DID_NO_CONNECT << 16);
1727 * - put current command back to issue queue
1728 * (reconnection of a disconnected nexus instead
1729 * of successful selection out)
1732 static void seldi_run(struct Scsi_Host *shpnt)
1736 unsigned long flags;
1738 SETPORT(SCSISIG, 0);
1739 SETPORT(SSTAT0, CLRSELDI);
1740 SETPORT(SSTAT1, CLRBUSFREE);
1741 SETPORT(SSTAT1, CLRPHASECHG);
1744 if(!(CURRENT_SC->SCp.phase & not_issued))
1745 printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1747 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1750 append_SC(&ISSUE_SC, CURRENT_SC);
1756 if(!DISCONNECTED_SC) {
1757 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1763 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1766 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1770 for(target=7; !(selid & (1 << target)); target--)
1773 if(selid & ~(1 << target)) {
1774 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1779 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1780 SETPORT(SCSISEQ, 0);
1782 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1784 RECONN_TARGET=target;
1785 DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1790 * - handle initial message after reconnection to identify
1791 * reconnecting nexus
1792 * - queue command on DISCONNECTED_SC on DISCONNECT message
1793 * - set completed flag on COMMAND COMPLETE
1794 * (other completition code moved to busfree_run)
1795 * - handle response to SDTR
1796 * - clear synchronous transfer agreements on BUS RESET
1798 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1801 static void msgi_run(struct Scsi_Host *shpnt)
1804 int sstat1 = GETPORT(SSTAT1);
1806 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1809 if(TESTLO(SSTAT0,SPIORDY)) {
1810 DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1814 ADDMSGI(GETPORT(SCSIDAT));
1816 #if defined(AHA152X_DEBUG)
1817 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1818 printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1819 spi_print_msg(&MSGI(0));
1825 if(LASTSTATE!=seldi) {
1826 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1830 * Handle reselection
1832 if(!(MSGI(0) & IDENTIFY_BASE)) {
1833 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1837 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1841 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1845 DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1847 CURRENT_SC->SCp.Message = MSGI(0);
1848 CURRENT_SC->SCp.phase &= ~disconnected;
1852 /* next message if any */
1856 CURRENT_SC->SCp.Message = MSGI(0);
1861 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1863 CURRENT_SC->SCp.phase |= disconnected;
1866 case COMMAND_COMPLETE:
1867 if(CURRENT_SC->SCp.phase & completed)
1868 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1870 CURRENT_SC->SCp.phase |= completed;
1873 case MESSAGE_REJECT:
1875 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1876 SYNCNEG=2; /* negotiation completed */
1878 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1884 case RESTORE_POINTERS:
1887 case EXTENDED_MESSAGE:
1888 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1889 /* not yet completed */
1899 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1903 if (!HOSTDATA(shpnt)->synchronous)
1906 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1907 spi_print_msg(&MSGI(0));
1910 ticks = (MSGI(3) * 4 + 49) / 50;
1913 /* negotiation in progress */
1914 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1915 ADDMSGO(MESSAGE_REJECT);
1916 printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1920 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1921 } else if (ticks <= 9 && MSGI(4) >= 1) {
1922 ADDMSGO(EXTENDED_MESSAGE);
1924 ADDMSGO(EXTENDED_SDTR);
1936 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1938 /* requested SDTR is too slow, do it asynchronously */
1939 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1940 ADDMSGO(MESSAGE_REJECT);
1943 SYNCNEG=2; /* negotiation completed */
1948 case BUS_DEVICE_RESET:
1952 for(i=0; i<8; i++) {
1953 HOSTDATA(shpnt)->syncrate[i]=0;
1954 HOSTDATA(shpnt)->syncneg[i]=0;
1960 case EXTENDED_MODIFY_DATA_POINTER:
1961 case EXTENDED_EXTENDED_IDENTIFY:
1964 ADDMSGO(MESSAGE_REJECT);
1974 static void msgi_end(struct Scsi_Host *shpnt)
1977 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
1979 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
1980 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
1981 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1989 static void msgo_init(struct Scsi_Host *shpnt)
1992 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
1993 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1995 printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
1996 ADDMSGO(MESSAGE_REJECT);
2000 #if defined(AHA152X_DEBUG)
2001 if(HOSTDATA(shpnt)->debug & debug_msgo) {
2004 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2005 for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2016 static void msgo_run(struct Scsi_Host *shpnt)
2019 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2021 while(MSGO_I<MSGOLEN) {
2022 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2024 if(TESTLO(SSTAT0, SPIORDY)) {
2025 DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2029 if (MSGO_I==MSGOLEN-1) {
2030 /* Leave MESSAGE OUT after transfer */
2031 SETPORT(SSTAT1, CLRATNO);
2035 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2036 CURRENT_SC->SCp.phase |= identified;
2038 if (MSGO(MSGO_I)==ABORT)
2039 CURRENT_SC->SCp.phase |= aborted;
2041 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2042 CURRENT_SC->SCp.phase |= resetted;
2044 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2048 static void msgo_end(struct Scsi_Host *shpnt)
2050 if(MSGO_I<MSGOLEN) {
2051 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2053 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2066 static void cmd_init(struct Scsi_Host *shpnt)
2068 if (CURRENT_SC->SCp.sent_command) {
2069 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2070 done(shpnt, DID_ERROR << 16);
2074 #if defined(AHA152X_DEBUG)
2075 if (HOSTDATA(shpnt)->debug & debug_cmd) {
2076 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2077 __scsi_print_command(CURRENT_SC->cmnd);
2088 static void cmd_run(struct Scsi_Host *shpnt)
2090 if(CMD_I==CURRENT_SC->cmd_len) {
2091 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2095 while(CMD_I<CURRENT_SC->cmd_len) {
2096 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);
2098 if(TESTLO(SSTAT0, SPIORDY)) {
2099 DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2103 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2107 static void cmd_end(struct Scsi_Host *shpnt)
2109 if(CMD_I<CURRENT_SC->cmd_len)
2110 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2112 CURRENT_SC->SCp.sent_command++;
2119 static void status_run(struct Scsi_Host *shpnt)
2121 if(TESTLO(SSTAT0,SPIORDY)) {
2122 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2126 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2128 #if defined(AHA152X_DEBUG)
2129 if (HOSTDATA(shpnt)->debug & debug_status) {
2130 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2131 scsi_print_status(CURRENT_SC->SCp.Status);
2141 static void datai_init(struct Scsi_Host *shpnt)
2143 SETPORT(DMACNTRL0, RSTFIFO);
2144 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2146 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2147 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2149 SETPORT(SIMODE0, 0);
2150 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2153 DPRINTK(debug_datai,
2154 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2155 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2156 scsi_get_resid(CURRENT_SC));
2159 static void datai_run(struct Scsi_Host *shpnt)
2161 unsigned long the_time;
2162 int fifodata, data_count;
2165 * loop while the phase persists or the fifos are not empty
2168 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2169 /* FIXME: maybe this should be done by setting up
2170 * STCNT to trigger ENSWRAP interrupt, instead of
2171 * polling for DFIFOFULL
2173 the_time=jiffies + 100*HZ;
2174 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2177 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2178 printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2183 if(TESTHI(DMASTAT, DFIFOFULL)) {
2186 the_time=jiffies + 100*HZ;
2187 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2190 if(TESTLO(SSTAT2, SEMPTY)) {
2191 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2196 fifodata = GETPORT(FIFOSTAT);
2199 if(CURRENT_SC->SCp.this_residual>0) {
2200 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2201 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2202 CURRENT_SC->SCp.this_residual :
2204 fifodata -= data_count;
2206 if(data_count & 1) {
2207 DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2208 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2209 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2210 CURRENT_SC->SCp.this_residual--;
2212 SETPORT(DMACNTRL0, ENDMA);
2215 if(data_count > 1) {
2216 DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2218 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2219 CURRENT_SC->SCp.ptr += 2 * data_count;
2220 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2221 DATA_LEN += 2 * data_count;
2224 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2225 /* advance to next buffer */
2226 CURRENT_SC->SCp.buffers_residual--;
2227 CURRENT_SC->SCp.buffer++;
2228 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2229 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2232 } else if(fifodata>0) {
2233 printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2234 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2237 data=GETPORT(DATAPORT);
2238 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2242 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2246 if(TESTLO(DMASTAT, INTSTAT) ||
2247 TESTLO(DMASTAT, DFIFOEMP) ||
2248 TESTLO(SSTAT2, SEMPTY) ||
2249 GETPORT(FIFOSTAT)>0) {
2251 * something went wrong, if there's something left in the fifos
2252 * or the phase didn't change
2254 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2258 if(DATA_LEN!=GETSTCNT()) {
2260 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2261 CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2267 static void datai_end(struct Scsi_Host *shpnt)
2269 CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2271 DPRINTK(debug_datai,
2272 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2273 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2274 scsi_get_resid(CURRENT_SC), GETSTCNT());
2276 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2277 SETPORT(DMACNTRL0, 0);
2284 static void datao_init(struct Scsi_Host *shpnt)
2286 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2287 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2289 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2290 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2292 SETPORT(SIMODE0, 0);
2293 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2295 DATA_LEN = scsi_get_resid(CURRENT_SC);
2297 DPRINTK(debug_datao,
2298 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2299 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2300 scsi_get_resid(CURRENT_SC));
2303 static void datao_run(struct Scsi_Host *shpnt)
2305 unsigned long the_time;
2308 /* until phase changes or all data sent */
2309 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2311 if(data_count > CURRENT_SC->SCp.this_residual)
2312 data_count=CURRENT_SC->SCp.this_residual;
2314 if(TESTLO(DMASTAT, DFIFOEMP)) {
2315 printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2320 if(data_count & 1) {
2321 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2322 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2323 CURRENT_SC->SCp.this_residual--;
2324 CMD_INC_RESID(CURRENT_SC, -1);
2325 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2328 if(data_count > 1) {
2330 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2331 CURRENT_SC->SCp.ptr += 2 * data_count;
2332 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2333 CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2336 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2337 /* advance to next buffer */
2338 CURRENT_SC->SCp.buffers_residual--;
2339 CURRENT_SC->SCp.buffer++;
2340 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2341 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2344 the_time=jiffies + 100*HZ;
2345 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2348 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2349 printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2356 static void datao_end(struct Scsi_Host *shpnt)
2358 if(TESTLO(DMASTAT, DFIFOEMP)) {
2359 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2362 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2363 CMDINFO(CURRENT_SC),
2365 DATA_LEN - scsi_get_resid(CURRENT_SC),
2368 CMD_INC_RESID(CURRENT_SC, data_count);
2370 data_count -= CURRENT_SC->SCp.ptr -
2371 SG_ADDRESS(CURRENT_SC->SCp.buffer);
2372 while(data_count>0) {
2373 CURRENT_SC->SCp.buffer--;
2374 CURRENT_SC->SCp.buffers_residual++;
2375 data_count -= CURRENT_SC->SCp.buffer->length;
2377 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2379 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2383 DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2384 CMDINFO(CURRENT_SC),
2385 scsi_bufflen(CURRENT_SC),
2386 scsi_get_resid(CURRENT_SC),
2389 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2390 SETPORT(SXFRCTL0, CH1);
2392 SETPORT(DMACNTRL0, 0);
2396 * figure out what state we're in
2399 static int update_state(struct Scsi_Host *shpnt)
2402 unsigned int stat0 = GETPORT(SSTAT0);
2403 unsigned int stat1 = GETPORT(SSTAT1);
2408 if(stat1 & SCSIRSTI) {
2411 SETPORT(SSTAT1,SCSIRSTI);
2412 } else if(stat0 & SELDI && PREVSTATE==busfree) {
2414 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2416 } else if(stat1 & SELTO) {
2418 } else if(stat1 & BUSFREE) {
2420 SETPORT(SSTAT1,BUSFREE);
2421 } else if(stat1 & SCSIPERR) {
2423 SETPORT(SSTAT1,SCSIPERR);
2424 } else if(stat1 & REQINIT) {
2425 switch(GETPORT(SCSISIG) & P_MASK) {
2426 case P_MSGI: STATE=msgi; break;
2427 case P_MSGO: STATE=msgo; break;
2428 case P_DATAO: STATE=datao; break;
2429 case P_DATAI: STATE=datai; break;
2430 case P_STATUS: STATE=status; break;
2431 case P_CMD: STATE=cmd; break;
2436 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2437 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2441 if(STATE!=PREVSTATE) {
2442 LASTSTATE=PREVSTATE;
2449 * handle parity error
2451 * FIXME: in which phase?
2454 static void parerr_run(struct Scsi_Host *shpnt)
2456 printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2457 done(shpnt, DID_PARITY << 16);
2464 static void rsti_run(struct Scsi_Host *shpnt)
2468 printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2470 ptr=DISCONNECTED_SC;
2472 Scsi_Cmnd *next = SCNEXT(ptr);
2474 if (!ptr->device->soft_reset) {
2475 remove_SC(&DISCONNECTED_SC, ptr);
2477 kfree(ptr->host_scribble);
2478 ptr->host_scribble=NULL;
2480 ptr->result = DID_RESET << 16;
2481 ptr->scsi_done(ptr);
2487 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2488 done(shpnt, DID_RESET << 16 );
2493 * bottom-half handler
2496 static void is_complete(struct Scsi_Host *shpnt)
2499 unsigned long flags;
2507 if( HOSTDATA(shpnt)->service==0 ) {
2512 HOSTDATA(shpnt)->service = 0;
2514 if(HOSTDATA(shpnt)->in_intr) {
2516 /* aha152x_error never returns.. */
2517 aha152x_error(shpnt, "bottom-half already running!?");
2519 HOSTDATA(shpnt)->in_intr++;
2522 * loop while there are interrupt conditions pending
2526 unsigned long start = jiffies;
2529 dataphase=update_state(shpnt);
2531 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2534 * end previous state
2537 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2538 states[PREVSTATE].end(shpnt);
2541 * disable SPIO mode if previous phase used it
2542 * and this one doesn't
2545 if(states[PREVSTATE].spio && !states[STATE].spio) {
2546 SETPORT(SXFRCTL0, CH1);
2547 SETPORT(DMACNTRL0, 0);
2549 CURRENT_SC->SCp.phase &= ~spiordy;
2553 * accept current dataphase phase
2557 SETPORT(SSTAT0, REQINIT);
2558 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2559 SETPORT(SSTAT1, PHASECHG);
2563 * enable SPIO mode if previous didn't use it
2567 if(!states[PREVSTATE].spio && states[STATE].spio) {
2568 SETPORT(DMACNTRL0, 0);
2569 SETPORT(SXFRCTL0, CH1|SPIOEN);
2571 CURRENT_SC->SCp.phase |= spiordy;
2575 * initialize for new state
2578 if(PREVSTATE!=STATE && states[STATE].init)
2579 states[STATE].init(shpnt);
2582 * handle current state
2585 if(states[STATE].run)
2586 states[STATE].run(shpnt);
2588 printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2591 * setup controller to interrupt on
2592 * the next expected condition and
2593 * loop if it's already there
2597 pending=setup_expected_interrupts(shpnt);
2598 #if defined(AHA152X_STAT)
2599 HOSTDATA(shpnt)->count[STATE]++;
2600 if(PREVSTATE!=STATE)
2601 HOSTDATA(shpnt)->count_trans[STATE]++;
2602 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2605 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2609 * enable interrupts and leave bottom-half
2612 HOSTDATA(shpnt)->in_intr--;
2613 SETBITS(DMACNTRL0, INTEN);
2619 * Dump the current driver status and panic
2621 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2623 printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2625 panic("aha152x panic\n");
2629 * Display registers of AIC-6260
2631 static void disp_ports(struct Scsi_Host *shpnt)
2633 #if defined(AHA152X_DEBUG)
2636 printk("\n%s: %s(%s) ",
2637 CURRENT_SC ? "busy" : "waiting",
2639 states[PREVSTATE].name);
2641 s = GETPORT(SCSISEQ);
2642 printk("SCSISEQ( ");
2644 printk("TARGET MODE ");
2652 printk("AUTOATNO ");
2654 printk("AUTOATNI ");
2656 printk("AUTOATNP ");
2658 printk("SCSIRSTO ");
2661 printk(" SCSISIG(");
2662 s = GETPORT(SCSISIG);
2663 switch (s & P_MASK) {
2677 printk("MESSAGE OUT");
2680 printk("MESSAGE IN");
2683 printk("*invalid*");
2689 printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2692 s = GETPORT(SSTAT0);
2710 s = GETPORT(SSTAT1);
2716 printk("SCSIRSTI ");
2718 printk("PHASEMIS ");
2722 printk("SCSIPERR ");
2724 printk("PHASECHG ");
2732 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2751 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2758 printk("SCSIRSTI ");
2760 printk("PHASEMIS ");
2764 printk("SCSIPERR ");
2766 printk("PHASECHG ");
2771 printk("SXFRCTL0( ");
2773 s = GETPORT(SXFRCTL0);
2781 printk("CLRSTCNT ");
2790 s = GETPORT(SCSISIG);
2803 printk("SELID (%02x), ", GETPORT(SELID));
2805 printk("STCNT (%d), ", GETSTCNT());
2809 s = GETPORT(SSTAT2);
2816 printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2818 s = GETPORT(SSTAT3);
2819 printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2822 s = GETPORT(SSTAT4);
2831 printk("DMACNTRL0( ");
2832 s = GETPORT(DMACNTRL0);
2833 printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2834 printk("%s ", s & DMA ? "DMA" : "PIO");
2835 printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2846 printk("DMASTAT( ");
2847 s = GETPORT(DMASTAT);
2853 printk("DFIFOFULL ");
2855 printk("DFIFOEMP ");
2861 * display enabled interrupts
2863 static void disp_enintr(struct Scsi_Host *shpnt)
2867 printk(KERN_DEBUG "enabled interrupts ( ");
2869 s = GETPORT(SIMODE0);
2875 printk("ENSELINGO ");
2881 printk("ENSPIORDY ");
2883 printk("ENDMADONE ");
2885 s = GETPORT(SIMODE1);
2887 printk("ENSELTIMO ");
2889 printk("ENATNTARG ");
2891 printk("ENPHASEMIS ");
2893 printk("ENBUSFREE ");
2895 printk("ENSCSIPERR ");
2897 printk("ENPHASECHG ");
2899 printk("ENREQINIT ");
2904 * Show the command data of a command
2906 static void show_command(Scsi_Cmnd *ptr)
2908 scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2910 __scsi_print_command(ptr->cmnd);
2912 printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2913 scsi_bufflen(ptr), scsi_get_resid(ptr));
2915 if (ptr->SCp.phase & not_issued)
2916 printk("not issued|");
2917 if (ptr->SCp.phase & selecting)
2918 printk("selecting|");
2919 if (ptr->SCp.phase & identified)
2920 printk("identified|");
2921 if (ptr->SCp.phase & disconnected)
2922 printk("disconnected|");
2923 if (ptr->SCp.phase & completed)
2924 printk("completed|");
2925 if (ptr->SCp.phase & spiordy)
2927 if (ptr->SCp.phase & syncneg)
2929 if (ptr->SCp.phase & aborted)
2931 if (ptr->SCp.phase & resetted)
2932 printk("resetted|");
2934 printk("; next=0x%p\n", SCNEXT(ptr));
2936 printk("; next=(host scribble NULL)\n");
2941 * Dump the queued data
2943 static void show_queues(struct Scsi_Host *shpnt)
2946 unsigned long flags;
2949 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2950 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2954 printk(KERN_DEBUG "current_SC:\n");
2956 show_command(CURRENT_SC);
2958 printk(KERN_DEBUG "none\n");
2960 printk(KERN_DEBUG "disconnected_SC:\n");
2961 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2969 #define SPRINTF(args...) pos += sprintf(pos, ## args)
2971 static int get_command(char *pos, Scsi_Cmnd * ptr)
2976 SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
2977 (unsigned int) ptr, ptr->device->id, ptr->device->lun);
2979 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2980 SPRINTF("0x%02x ", ptr->cmnd[i]);
2982 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
2983 scsi_get_resid(ptr), ptr->SCp.this_residual,
2984 ptr->SCp.buffers_residual);
2986 if (ptr->SCp.phase & not_issued)
2987 SPRINTF("not issued|");
2988 if (ptr->SCp.phase & selecting)
2989 SPRINTF("selecting|");
2990 if (ptr->SCp.phase & disconnected)
2991 SPRINTF("disconnected|");
2992 if (ptr->SCp.phase & aborted)
2993 SPRINTF("aborted|");
2994 if (ptr->SCp.phase & identified)
2995 SPRINTF("identified|");
2996 if (ptr->SCp.phase & completed)
2997 SPRINTF("completed|");
2998 if (ptr->SCp.phase & spiordy)
2999 SPRINTF("spiordy|");
3000 if (ptr->SCp.phase & syncneg)
3001 SPRINTF("syncneg|");
3002 SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3004 return (pos - start);
3007 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3012 SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3014 s = GETPORT(SCSISEQ);
3015 SPRINTF("SCSISEQ( ");
3017 SPRINTF("TARGET MODE ");
3025 SPRINTF("AUTOATNO ");
3027 SPRINTF("AUTOATNI ");
3029 SPRINTF("AUTOATNP ");
3031 SPRINTF("SCSIRSTO ");
3034 SPRINTF(" SCSISIG(");
3035 s = GETPORT(SCSISIG);
3036 switch (s & P_MASK) {
3038 SPRINTF("DATA OUT");
3050 SPRINTF("MESSAGE OUT");
3053 SPRINTF("MESSAGE IN");
3056 SPRINTF("*invalid*");
3062 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3065 s = GETPORT(SSTAT0);
3073 SPRINTF("SELINGO ");
3079 SPRINTF("SPIORDY ");
3081 SPRINTF("DMADONE ");
3083 s = GETPORT(SSTAT1);
3087 SPRINTF("ATNTARG ");
3089 SPRINTF("SCSIRSTI ");
3091 SPRINTF("PHASEMIS ");
3093 SPRINTF("BUSFREE ");
3095 SPRINTF("SCSIPERR ");
3097 SPRINTF("PHASECHG ");
3099 SPRINTF("REQINIT ");
3105 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3114 SPRINTF("SELINGO ");
3120 SPRINTF("SPIORDY ");
3122 SPRINTF("DMADONE ");
3124 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3129 SPRINTF("ATNTARG ");
3131 SPRINTF("SCSIRSTI ");
3133 SPRINTF("PHASEMIS ");
3135 SPRINTF("BUSFREE ");
3137 SPRINTF("SCSIPERR ");
3139 SPRINTF("PHASECHG ");
3141 SPRINTF("REQINIT ");
3144 SPRINTF("SXFRCTL0( ");
3146 s = GETPORT(SXFRCTL0);
3154 SPRINTF("CLRSTCNT ");
3161 SPRINTF("SIGNAL( ");
3163 s = GETPORT(SCSISIG);
3176 SPRINTF("SELID(%02x), ", GETPORT(SELID));
3178 SPRINTF("STCNT(%d), ", GETSTCNT());
3180 SPRINTF("SSTAT2( ");
3182 s = GETPORT(SSTAT2);
3184 SPRINTF("SOFFSET ");
3189 SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3191 s = GETPORT(SSTAT3);
3192 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3194 SPRINTF("SSTAT4( ");
3195 s = GETPORT(SSTAT4);
3197 SPRINTF("SYNCERR ");
3204 SPRINTF("DMACNTRL0( ");
3205 s = GETPORT(DMACNTRL0);
3206 SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3207 SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3208 SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3214 SPRINTF("RSTFIFO ");
3219 SPRINTF("DMASTAT( ");
3220 s = GETPORT(DMASTAT);
3224 SPRINTF("WORDRDY ");
3226 SPRINTF("DFIFOFULL ");
3228 SPRINTF("DFIFOEMP ");
3231 SPRINTF("enabled interrupts( ");
3233 s = GETPORT(SIMODE0);
3235 SPRINTF("ENSELDO ");
3237 SPRINTF("ENSELDI ");
3239 SPRINTF("ENSELINGO ");
3241 SPRINTF("ENSWRAP ");
3243 SPRINTF("ENSDONE ");
3245 SPRINTF("ENSPIORDY ");
3247 SPRINTF("ENDMADONE ");
3249 s = GETPORT(SIMODE1);
3251 SPRINTF("ENSELTIMO ");
3253 SPRINTF("ENATNTARG ");
3255 SPRINTF("ENPHASEMIS ");
3257 SPRINTF("ENBUSFREE ");
3259 SPRINTF("ENSCSIPERR ");
3261 SPRINTF("ENPHASECHG ");
3263 SPRINTF("ENREQINIT ");
3266 return (pos - start);
3269 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3271 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3274 #if defined(AHA152X_DEBUG)
3275 if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3276 int debug = HOSTDATA(shpnt)->debug;
3278 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3280 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3283 #if defined(AHA152X_STAT)
3284 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3287 HOSTDATA(shpnt)->total_commands=0;
3288 HOSTDATA(shpnt)->disconnections=0;
3289 HOSTDATA(shpnt)->busfree_without_any_action=0;
3290 HOSTDATA(shpnt)->busfree_without_old_command=0;
3291 HOSTDATA(shpnt)->busfree_without_new_command=0;
3292 HOSTDATA(shpnt)->busfree_without_done_command=0;
3293 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3294 for (i = idle; i<maxstate; i++) {
3295 HOSTDATA(shpnt)->count[i]=0;
3296 HOSTDATA(shpnt)->count_trans[i]=0;
3297 HOSTDATA(shpnt)->time[i]=0;
3300 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3313 #define SPRINTF(args...) \
3314 do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3316 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3317 off_t offset, int length, int inout)
3322 unsigned long flags;
3325 DPRINTK(debug_procinfo,
3326 KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3327 buffer, offset, length, shpnt->host_no, inout);
3331 return aha152x_set_info(buffer, length, shpnt);
3333 SPRINTF(AHA152X_REVID "\n");
3335 SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3336 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3337 SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3338 SPRINTF("disconnection/reconnection %s\n",
3339 RECONNECT ? "enabled" : "disabled");
3340 SPRINTF("parity checking %s\n",
3341 PARITY ? "enabled" : "disabled");
3342 SPRINTF("synchronous transfers %s\n",
3343 SYNCHRONOUS ? "enabled" : "disabled");
3344 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3347 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3348 for (i = 0; i < 8; i++)
3349 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3350 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3352 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3353 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3354 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3356 #if defined(AHA152X_DEBUG)
3357 #define PDEBUG(flags,txt) \
3358 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3360 SPRINTF("enabled debugging options: ");
3362 PDEBUG(debug_procinfo, "procinfo");
3363 PDEBUG(debug_queue, "queue");
3364 PDEBUG(debug_intr, "interrupt");
3365 PDEBUG(debug_selection, "selection");
3366 PDEBUG(debug_msgo, "message out");
3367 PDEBUG(debug_msgi, "message in");
3368 PDEBUG(debug_status, "status");
3369 PDEBUG(debug_cmd, "command");
3370 PDEBUG(debug_datai, "data in");
3371 PDEBUG(debug_datao, "data out");
3372 PDEBUG(debug_eh, "eh");
3373 PDEBUG(debug_locking, "locks");
3374 PDEBUG(debug_phases, "phases");
3379 SPRINTF("\nqueue status:\n");
3382 SPRINTF("not yet issued commands:\n");
3383 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3384 pos += get_command(pos, ptr);
3386 SPRINTF("no not yet issued commands\n");
3390 SPRINTF("current command:\n");
3391 pos += get_command(pos, CURRENT_SC);
3393 SPRINTF("no current command\n");
3395 if (DISCONNECTED_SC) {
3396 SPRINTF("disconnected commands:\n");
3397 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3398 pos += get_command(pos, ptr);
3400 SPRINTF("no disconnected commands\n");
3402 pos += get_ports(shpnt, pos);
3404 #if defined(AHA152X_STAT)
3405 SPRINTF("statistics:\n"
3406 "total commands: %d\n"
3407 "disconnections: %d\n"
3408 "busfree with check condition: %d\n"
3409 "busfree without old command: %d\n"
3410 "busfree without new command: %d\n"
3411 "busfree without done command: %d\n"
3412 "busfree without any action: %d\n"
3417 HOSTDATA(shpnt)->total_commands,
3418 HOSTDATA(shpnt)->disconnections,
3419 HOSTDATA(shpnt)->busfree_with_check_condition,
3420 HOSTDATA(shpnt)->busfree_without_old_command,
3421 HOSTDATA(shpnt)->busfree_without_new_command,
3422 HOSTDATA(shpnt)->busfree_without_done_command,
3423 HOSTDATA(shpnt)->busfree_without_any_action);
3424 for(i=0; i<maxstate; i++) {
3425 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3427 HOSTDATA(shpnt)->count_trans[i],
3428 HOSTDATA(shpnt)->count[i],
3429 HOSTDATA(shpnt)->time[i]);
3433 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3435 thislength = pos - (buffer + offset);
3436 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3439 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3444 thislength = thislength<length ? thislength : length;
3446 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3448 *start = buffer + offset;
3449 return thislength < length ? thislength : length;
3452 static int aha152x_adjust_queue(struct scsi_device *device)
3454 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
3458 static struct scsi_host_template aha152x_driver_template = {
3459 .module = THIS_MODULE,
3460 .name = AHA152X_REVID,
3461 .proc_name = "aha152x",
3462 .proc_info = aha152x_proc_info,
3463 .queuecommand = aha152x_queue,
3464 .eh_abort_handler = aha152x_abort,
3465 .eh_device_reset_handler = aha152x_device_reset,
3466 .eh_bus_reset_handler = aha152x_bus_reset,
3467 .eh_host_reset_handler = aha152x_host_reset,
3468 .bios_param = aha152x_biosparam,
3471 .sg_tablesize = SG_ALL,
3473 .use_clustering = DISABLE_CLUSTERING,
3474 .slave_alloc = aha152x_adjust_queue,
3477 #if !defined(PCMCIA)
3478 static int setup_count;
3479 static struct aha152x_setup setup[2];
3481 /* possible i/o addresses for the AIC-6260; default first */
3482 static unsigned short ports[] = { 0x340, 0x140 };
3484 #if !defined(SKIP_BIOSTEST)
3485 /* possible locations for the Adaptec BIOS; defaults first */
3486 static unsigned int addresses[] =
3488 0xdc000, /* default first */
3495 0xeb800, /* VTech Platinum SMP */
3499 /* signatures for various AIC-6[23]60 based controllers.
3500 The point in detecting signatures is to avoid useless and maybe
3501 harmful probes on ports. I'm not sure that all listed boards pass
3502 auto-configuration. For those which fail the BIOS signature is
3503 obsolete, because user intervention to supply the configuration is
3504 needed anyway. May be an information whether or not the BIOS supports
3505 extended translation could be also useful here. */
3506 static struct signature {
3507 unsigned char *signature;
3512 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3514 { "Adaptec AHA-1520B", 0x000b, 17 },
3515 /* Adaptec 152x rev B */
3516 { "Adaptec AHA-1520B", 0x0026, 17 },
3517 /* Iomega Jaz Jet ISA (AIC6370Q) */
3518 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3519 /* on-board controller */
3520 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3521 /* on-board controller */
3522 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3523 /* on-board controller */
3524 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3525 /* on-board controller */
3526 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3527 /* ScsiPro-Controller */
3528 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3529 /* Gigabyte Local-Bus-SCSI */
3530 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3532 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3533 /* IBM Thinkpad Dock II */
3534 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3535 /* IBM Thinkpad Dock II SCSI */
3536 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3537 /* DTC 3520A ISA SCSI */
3539 #endif /* !SKIP_BIOSTEST */
3542 * Test, if port_base is valid.
3545 static int aha152x_porttest(int io_port)
3549 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3550 for (i = 0; i < 16; i++)
3551 SETPORT(io_port + O_STACK, i);
3553 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3554 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3560 static int tc1550_porttest(int io_port)
3564 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3565 for (i = 0; i < 16; i++)
3566 SETPORT(io_port + O_STACK, i);
3568 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3569 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3576 static int checksetup(struct aha152x_setup *setup)
3579 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3582 if (i == ARRAY_SIZE(ports))
3585 if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) {
3586 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3590 if( aha152x_porttest(setup->io_port) ) {
3592 } else if( tc1550_porttest(setup->io_port) ) {
3595 release_region(setup->io_port, IO_RANGE);
3599 release_region(setup->io_port, IO_RANGE);
3601 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3604 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3607 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3610 if ((setup->parity < 0) || (setup->parity > 1))
3613 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3616 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3624 static int __init aha152x_init(void)
3627 #if defined(AUTOCONF)
3628 aha152x_config conf;
3631 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3634 if ( setup_count ) {
3635 printk(KERN_INFO "aha152x: processing commandline: ");
3637 for (i = 0; i<setup_count; i++) {
3638 if (!checksetup(&setup[i])) {
3639 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3640 printk(KERN_ERR "aha152x: invalid line\n");
3647 if (setup_count < ARRAY_SIZE(setup)) {
3648 struct aha152x_setup override = SETUP0;
3650 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3651 if (!checksetup(&override)) {
3652 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3658 override.synchronous,
3660 override.ext_trans);
3662 setup[setup_count++] = override;
3668 if (setup_count < ARRAY_SIZE(setup)) {
3669 struct aha152x_setup override = SETUP1;
3671 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3672 if (!checksetup(&override)) {
3673 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3679 override.synchronous,
3681 override.ext_trans);
3683 setup[setup_count++] = override;
3689 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3691 setup[setup_count].conf = "";
3692 setup[setup_count].io_port = aha152x[0];
3693 setup[setup_count].irq = aha152x[1];
3694 setup[setup_count].scsiid = aha152x[2];
3695 setup[setup_count].reconnect = aha152x[3];
3696 setup[setup_count].parity = aha152x[4];
3697 setup[setup_count].synchronous = aha152x[5];
3698 setup[setup_count].delay = aha152x[6];
3699 setup[setup_count].ext_trans = aha152x[7];
3700 #if defined(AHA152X_DEBUG)
3701 setup[setup_count].debug = aha152x[8];
3703 } else if(io[0]!=0 || irq[0]!=0) {
3704 if(io[0]!=0) setup[setup_count].io_port = io[0];
3705 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3707 setup[setup_count].scsiid = scsiid[0];
3708 setup[setup_count].reconnect = reconnect[0];
3709 setup[setup_count].parity = parity[0];
3710 setup[setup_count].synchronous = sync[0];
3711 setup[setup_count].delay = delay[0];
3712 setup[setup_count].ext_trans = exttrans[0];
3713 #if defined(AHA152X_DEBUG)
3714 setup[setup_count].debug = debug[0];
3718 if (checksetup(&setup[setup_count]))
3721 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",
3722 setup[setup_count].io_port,
3723 setup[setup_count].irq,
3724 setup[setup_count].scsiid,
3725 setup[setup_count].reconnect,
3726 setup[setup_count].parity,
3727 setup[setup_count].synchronous,
3728 setup[setup_count].delay,
3729 setup[setup_count].ext_trans);
3732 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3733 if(aha152x1[0]!=0) {
3734 setup[setup_count].conf = "";
3735 setup[setup_count].io_port = aha152x1[0];
3736 setup[setup_count].irq = aha152x1[1];
3737 setup[setup_count].scsiid = aha152x1[2];
3738 setup[setup_count].reconnect = aha152x1[3];
3739 setup[setup_count].parity = aha152x1[4];
3740 setup[setup_count].synchronous = aha152x1[5];
3741 setup[setup_count].delay = aha152x1[6];
3742 setup[setup_count].ext_trans = aha152x1[7];
3743 #if defined(AHA152X_DEBUG)
3744 setup[setup_count].debug = aha152x1[8];
3746 } else if(io[1]!=0 || irq[1]!=0) {
3747 if(io[1]!=0) setup[setup_count].io_port = io[1];
3748 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3750 setup[setup_count].scsiid = scsiid[1];
3751 setup[setup_count].reconnect = reconnect[1];
3752 setup[setup_count].parity = parity[1];
3753 setup[setup_count].synchronous = sync[1];
3754 setup[setup_count].delay = delay[1];
3755 setup[setup_count].ext_trans = exttrans[1];
3756 #if defined(AHA152X_DEBUG)
3757 setup[setup_count].debug = debug[1];
3760 if (checksetup(&setup[setup_count]))
3763 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",
3764 setup[setup_count].io_port,
3765 setup[setup_count].irq,
3766 setup[setup_count].scsiid,
3767 setup[setup_count].reconnect,
3768 setup[setup_count].parity,
3769 setup[setup_count].synchronous,
3770 setup[setup_count].delay,
3771 setup[setup_count].ext_trans);
3776 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3777 while ( setup_count<ARRAY_SIZE(setup) &&
3778 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3779 if (pnp_device_attach(dev) < 0)
3782 if (pnp_activate_dev(dev) < 0) {
3783 pnp_device_detach(dev);
3787 if (!pnp_port_valid(dev, 0)) {
3788 pnp_device_detach(dev);
3792 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3793 pnp_device_detach(dev);
3797 setup[setup_count].io_port = pnp_port_start(dev, 0);
3798 setup[setup_count].irq = pnp_irq(dev, 0);
3799 setup[setup_count].scsiid = 7;
3800 setup[setup_count].reconnect = 1;
3801 setup[setup_count].parity = 1;
3802 setup[setup_count].synchronous = 1;
3803 setup[setup_count].delay = DELAY_DEFAULT;
3804 setup[setup_count].ext_trans = 0;
3805 #if defined(AHA152X_DEBUG)
3806 setup[setup_count].debug = DEBUG_DEFAULT;
3808 #if defined(__ISAPNP__)
3809 pnpdev[setup_count] = dev;
3812 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3813 setup[setup_count].io_port, setup[setup_count].irq);
3819 #if defined(AUTOCONF)
3820 if (setup_count<ARRAY_SIZE(setup)) {
3821 #if !defined(SKIP_BIOSTEST)
3823 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3824 void __iomem *p = ioremap(addresses[i], 0x4000);
3827 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3828 ok = check_signature(p + signatures[j].sig_offset,
3829 signatures[j].signature, signatures[j].sig_length);
3832 if (!ok && setup_count == 0)
3835 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3837 printk(KERN_INFO "aha152x: ");
3838 #endif /* !SKIP_BIOSTEST */
3841 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3842 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3845 if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) {
3846 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3850 if (aha152x_porttest(ports[i])) {
3851 setup[setup_count].tc1550 = 0;
3854 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3855 } else if (tc1550_porttest(ports[i])) {
3856 setup[setup_count].tc1550 = 1;
3859 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3861 release_region(ports[i], IO_RANGE);
3865 release_region(ports[i], IO_RANGE);
3868 setup[setup_count].io_port = ports[i];
3869 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3870 setup[setup_count].scsiid = conf.cf_id;
3871 setup[setup_count].reconnect = conf.cf_tardisc;
3872 setup[setup_count].parity = !conf.cf_parity;
3873 setup[setup_count].synchronous = conf.cf_syncneg;
3874 setup[setup_count].delay = DELAY_DEFAULT;
3875 setup[setup_count].ext_trans = 0;
3876 #if defined(AHA152X_DEBUG)
3877 setup[setup_count].debug = DEBUG_DEFAULT;
3884 printk("auto configuration: ok, ");
3888 printk("%d controller(s) configured\n", setup_count);
3890 for (i=0; i<setup_count; i++) {
3891 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3892 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3895 release_region(setup[i].io_port, IO_RANGE);
3896 #if defined(__ISAPNP__)
3897 } else if( pnpdev[i] ) {
3898 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3903 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3906 #if defined(__ISAPNP__)
3908 pnp_device_detach(pnpdev[i]);
3915 static void __exit aha152x_exit(void)
3917 struct aha152x_hostdata *hd, *tmp;
3919 list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3920 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3922 aha152x_release(shost);
3926 module_init(aha152x_init);
3927 module_exit(aha152x_exit);
3929 #if !defined(MODULE)
3930 static int __init aha152x_setup(char *str)
3932 #if defined(AHA152X_DEBUG)
3937 get_options(str, ARRAY_SIZE(ints), ints);
3939 if(setup_count>=ARRAY_SIZE(setup)) {
3940 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3944 setup[setup_count].conf = str;
3945 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3946 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3947 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3948 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3949 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3950 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3951 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3952 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3953 #if defined(AHA152X_DEBUG)
3954 setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3956 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3957 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3959 if (ints[0] > 8) { /*}*/
3960 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3961 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3970 __setup("aha152x=", aha152x_setup);
3973 #endif /* !PCMCIA */