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 */
554 unsigned char cmd_len;
555 unsigned char cmnd[MAX_COMMAND_SIZE];
556 unsigned short use_sg;
557 unsigned request_bufflen;
558 void *request_buffer;
562 /* access macros for hostdata */
564 #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
566 #define HOSTNO ((shpnt)->host_no)
568 #define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
569 #define DONE_SC (HOSTDATA(shpnt)->done_SC)
570 #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
571 #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
572 #define QLOCK (HOSTDATA(shpnt)->lock)
573 #define QLOCKER (HOSTDATA(shpnt)->locker)
574 #define QLOCKERL (HOSTDATA(shpnt)->lockerl)
576 #define STATE (HOSTDATA(shpnt)->state)
577 #define PREVSTATE (HOSTDATA(shpnt)->prevstate)
578 #define LASTSTATE (HOSTDATA(shpnt)->laststate)
580 #define RECONN_TARGET (HOSTDATA(shpnt)->target)
582 #define CMD_I (HOSTDATA(shpnt)->cmd_i)
584 #define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
585 #define MSGO_I (HOSTDATA(shpnt)->msgo_i)
586 #define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
587 #define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
589 #define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
590 #define MSGILEN (HOSTDATA(shpnt)->msgi_len)
591 #define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
593 #define DATA_LEN (HOSTDATA(shpnt)->data_len)
595 #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
596 #define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
598 #define DELAY (HOSTDATA(shpnt)->delay)
599 #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
600 #define TC1550 (HOSTDATA(shpnt)->tc1550)
601 #define RECONNECT (HOSTDATA(shpnt)->reconnect)
602 #define PARITY (HOSTDATA(shpnt)->parity)
603 #define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
605 #define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
606 #define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
608 #define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
609 #define SCNEXT(SCpnt) SCDATA(SCpnt)->next
610 #define SCSEM(SCpnt) SCDATA(SCpnt)->sem
612 #define SG_ADDRESS(buffer) ((char *) (page_address((buffer)->page)+(buffer)->offset))
615 static void seldi_run(struct Scsi_Host *shpnt);
616 static void seldo_run(struct Scsi_Host *shpnt);
617 static void selto_run(struct Scsi_Host *shpnt);
618 static void busfree_run(struct Scsi_Host *shpnt);
620 static void msgo_init(struct Scsi_Host *shpnt);
621 static void msgo_run(struct Scsi_Host *shpnt);
622 static void msgo_end(struct Scsi_Host *shpnt);
624 static void cmd_init(struct Scsi_Host *shpnt);
625 static void cmd_run(struct Scsi_Host *shpnt);
626 static void cmd_end(struct Scsi_Host *shpnt);
628 static void datai_init(struct Scsi_Host *shpnt);
629 static void datai_run(struct Scsi_Host *shpnt);
630 static void datai_end(struct Scsi_Host *shpnt);
632 static void datao_init(struct Scsi_Host *shpnt);
633 static void datao_run(struct Scsi_Host *shpnt);
634 static void datao_end(struct Scsi_Host *shpnt);
636 static void status_run(struct Scsi_Host *shpnt);
638 static void msgi_run(struct Scsi_Host *shpnt);
639 static void msgi_end(struct Scsi_Host *shpnt);
641 static void parerr_run(struct Scsi_Host *shpnt);
642 static void rsti_run(struct Scsi_Host *shpnt);
644 static void is_complete(struct Scsi_Host *shpnt);
652 void (*init)(struct Scsi_Host *);
653 void (*run)(struct Scsi_Host *);
654 void (*end)(struct Scsi_Host *);
657 { "idle", NULL, NULL, NULL, 0},
658 { "unknown", NULL, NULL, NULL, 0},
659 { "seldo", NULL, seldo_run, NULL, 0},
660 { "seldi", NULL, seldi_run, NULL, 0},
661 { "selto", NULL, selto_run, NULL, 0},
662 { "busfree", NULL, busfree_run, NULL, 0},
663 { "msgo", msgo_init, msgo_run, msgo_end, 1},
664 { "cmd", cmd_init, cmd_run, cmd_end, 1},
665 { "msgi", NULL, msgi_run, msgi_end, 1},
666 { "status", NULL, status_run, NULL, 1},
667 { "datai", datai_init, datai_run, datai_end, 0},
668 { "datao", datao_init, datao_run, datao_end, 0},
669 { "parerr", NULL, parerr_run, NULL, 0},
670 { "rsti", NULL, rsti_run, NULL, 0},
673 /* setup & interrupt */
674 static irqreturn_t intr(int irq, void *dev_id, struct pt_regs *);
675 static void reset_ports(struct Scsi_Host *shpnt);
676 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
677 static void done(struct Scsi_Host *shpnt, int error);
680 static void disp_ports(struct Scsi_Host *shpnt);
681 static void show_command(Scsi_Cmnd * ptr);
682 static void show_queues(struct Scsi_Host *shpnt);
683 static void disp_enintr(struct Scsi_Host *shpnt);
690 static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
694 SCNEXT(new_SC) = NULL;
698 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
700 SCNEXT(end) = new_SC;
704 static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
716 static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
718 Scsi_Cmnd *ptr, *prev;
720 for (ptr = *SC, prev = NULL;
721 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
722 prev = ptr, ptr = SCNEXT(ptr))
727 SCNEXT(prev) = SCNEXT(ptr);
737 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
739 Scsi_Cmnd *ptr, *prev;
741 for (ptr = *SC, prev = NULL;
743 prev = ptr, ptr = SCNEXT(ptr))
748 SCNEXT(prev) = SCNEXT(ptr);
758 static inline struct Scsi_Host *lookup_irq(int irqno)
762 for(i=0; i<ARRAY_SIZE(aha152x_host); i++)
763 if(aha152x_host[i] && aha152x_host[i]->irq==irqno)
764 return aha152x_host[i];
769 static irqreturn_t swintr(int irqno, void *dev_id, struct pt_regs *regs)
771 struct Scsi_Host *shpnt = lookup_irq(irqno);
774 printk(KERN_ERR "aha152x: catched software interrupt %d for unknown controller.\n", irqno);
778 HOSTDATA(shpnt)->swint++;
780 SETPORT(DMACNTRL0, INTEN);
784 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
786 struct Scsi_Host *shpnt;
788 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
790 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
794 /* need to have host registered before triggering any interrupt */
795 aha152x_host[registered_count] = shpnt;
797 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
799 shpnt->io_port = setup->io_port;
800 shpnt->n_io_port = IO_RANGE;
801 shpnt->irq = setup->irq;
803 if (!setup->tc1550) {
804 HOSTIOPORT0 = setup->io_port;
805 HOSTIOPORT1 = setup->io_port;
807 HOSTIOPORT0 = setup->io_port+0x10;
808 HOSTIOPORT1 = setup->io_port-0x10;
811 spin_lock_init(&QLOCK);
812 RECONNECT = setup->reconnect;
813 SYNCHRONOUS = setup->synchronous;
814 PARITY = setup->parity;
815 DELAY = setup->delay;
816 EXT_TRANS = setup->ext_trans;
818 #if defined(AHA152X_DEBUG)
819 HOSTDATA(shpnt)->debug = setup->debug;
822 SETPORT(SCSIID, setup->scsiid << 4);
823 shpnt->this_id = setup->scsiid;
825 if (setup->reconnect)
826 shpnt->can_queue = AHA152X_MAXQUEUE;
829 printk("aha152x: resetting bus...\n");
830 SETPORT(SCSISEQ, SCSIRSTO);
839 "vital data: rev=%x, "
840 "io=0x%03lx (0x%03lx/0x%03lx), "
847 "extended translation=%s\n",
848 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
850 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
853 RECONNECT ? "enabled" : "disabled",
854 PARITY ? "enabled" : "disabled",
855 SYNCHRONOUS ? "enabled" : "disabled",
857 EXT_TRANS ? "enabled" : "disabled");
859 /* not expecting any interrupts */
863 if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
864 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
868 HOSTDATA(shpnt)->swint = 0;
870 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
873 SETPORT(DMACNTRL0, SWINT|INTEN);
875 free_irq(shpnt->irq, shpnt);
877 if (!HOSTDATA(shpnt)->swint) {
878 if (TESTHI(DMASTAT, INTSTAT)) {
884 SETPORT(DMACNTRL0, INTEN);
886 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
887 "Please verify.\n", shpnt->host_no, shpnt->irq);
893 /* clear interrupts */
894 SETPORT(SSTAT0, 0x7f);
895 SETPORT(SSTAT1, 0xef);
897 if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
898 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
902 if( scsi_add_host(shpnt, NULL) ) {
903 free_irq(shpnt->irq, shpnt);
904 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
908 scsi_scan_host(shpnt);
915 aha152x_host[registered_count]=NULL;
916 scsi_host_put(shpnt);
921 void aha152x_release(struct Scsi_Host *shpnt)
927 free_irq(shpnt->irq, shpnt);
931 release_region(shpnt->io_port, IO_RANGE);
935 if (HOSTDATA(shpnt)->pnpdev)
936 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
939 scsi_remove_host(shpnt);
940 scsi_host_put(shpnt);
945 * setup controller to generate interrupts depending
946 * on current state (lock has to be acquired)
949 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
952 CURRENT_SC->SCp.phase |= 1 << 16;
954 if(CURRENT_SC->SCp.phase & selecting) {
955 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
956 SETPORT(SSTAT1, SELTO);
957 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
958 SETPORT(SIMODE1, ENSELTIMO);
960 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
961 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
962 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
964 } else if(STATE==seldi) {
965 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
967 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
969 DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
971 DISCONNECTED_SC ? "(reselection)" : "",
972 ISSUE_SC ? "(busfree)" : "");
973 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
974 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
977 if(!HOSTDATA(shpnt)->in_intr)
978 SETBITS(DMACNTRL0, INTEN);
980 return TESTHI(DMASTAT, INTSTAT);
985 * Queue a command and setup interrupts for a free bus.
987 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct semaphore *sem, int phase, void (*done)(Scsi_Cmnd *))
989 struct Scsi_Host *shpnt = SCpnt->device->host;
992 #if defined(AHA152X_DEBUG)
993 if (HOSTDATA(shpnt)->debug & debug_queue) {
994 printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
995 CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len, SCpnt->use_sg, SCpnt->request_bufflen);
996 __scsi_print_command(SCpnt->cmnd);
1000 SCpnt->scsi_done = done;
1001 SCpnt->resid = SCpnt->request_bufflen;
1002 SCpnt->SCp.phase = not_issued | phase;
1003 SCpnt->SCp.Status = CHECK_CONDITION;
1004 SCpnt->SCp.Message = 0;
1005 SCpnt->SCp.have_data_in = 0;
1006 SCpnt->SCp.sent_command = 0;
1008 if(SCpnt->SCp.phase & (resetting|check_condition)) {
1009 if(SCpnt->host_scribble==0 || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
1010 printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1014 struct aha152x_scdata *sc;
1016 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1017 if(SCpnt->host_scribble==0) {
1018 printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1023 memcpy(sc->cmnd, SCpnt->cmnd, sizeof(sc->cmnd));
1024 sc->request_buffer = SCpnt->request_buffer;
1025 sc->request_bufflen = SCpnt->request_bufflen;
1026 sc->use_sg = SCpnt->use_sg;
1027 sc->cmd_len = SCpnt->cmd_len;
1030 SCNEXT(SCpnt) = NULL;
1033 /* setup scratch area
1034 SCp.ptr : buffer pointer
1035 SCp.this_residual : buffer length
1036 SCp.buffer : next buffer
1037 SCp.buffers_residual : left buffers in list
1038 SCp.phase : current state of the command */
1039 if (SCpnt->use_sg) {
1040 SCpnt->SCp.buffer = (struct scatterlist *) SCpnt->request_buffer;
1041 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
1042 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
1043 SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1;
1045 SCpnt->SCp.ptr = (char *) SCpnt->request_buffer;
1046 SCpnt->SCp.this_residual = SCpnt->request_bufflen;
1047 SCpnt->SCp.buffer = NULL;
1048 SCpnt->SCp.buffers_residual = 0;
1053 #if defined(AHA152X_STAT)
1054 HOSTDATA(shpnt)->total_commands++;
1057 /* Turn led on, when this is the first command. */
1058 HOSTDATA(shpnt)->commands++;
1059 if (HOSTDATA(shpnt)->commands==1)
1062 append_SC(&ISSUE_SC, SCpnt);
1064 if(!HOSTDATA(shpnt)->in_intr)
1065 setup_expected_interrupts(shpnt);
1076 static int aha152x_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1079 if(*SCpnt->cmnd == REQUEST_SENSE) {
1087 return aha152x_internal_queue(SCpnt, NULL, 0, done);
1095 static void reset_done(Scsi_Cmnd *SCpnt)
1098 struct Scsi_Host *shpnt = SCpnt->host;
1099 DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1104 printk(KERN_ERR "aha152x: reset_done w/o semaphore\n");
1112 static int aha152x_abort(Scsi_Cmnd *SCpnt)
1114 struct Scsi_Host *shpnt = SCpnt->device->host;
1116 unsigned long flags;
1118 #if defined(AHA152X_DEBUG)
1119 if(HOSTDATA(shpnt)->debug & debug_eh) {
1120 printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1127 ptr=remove_SC(&ISSUE_SC, SCpnt);
1130 DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1132 HOSTDATA(shpnt)->commands--;
1133 if (!HOSTDATA(shpnt)->commands)
1137 kfree(SCpnt->host_scribble);
1138 SCpnt->host_scribble=NULL;
1147 * for current command: queue ABORT for message out and raise ATN
1148 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1152 printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1157 static void timer_expired(unsigned long p)
1159 Scsi_Cmnd *SCp = (Scsi_Cmnd *)p;
1160 struct semaphore *sem = SCSEM(SCp);
1161 struct Scsi_Host *shpnt = SCp->device->host;
1162 unsigned long flags;
1164 /* remove command from issue queue */
1166 remove_SC(&ISSUE_SC, SCp);
1176 static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1178 struct Scsi_Host *shpnt = SCpnt->device->host;
1179 DECLARE_MUTEX_LOCKED(sem);
1180 struct timer_list timer;
1181 int ret, issued, disconnected;
1182 unsigned long flags;
1184 #if defined(AHA152X_DEBUG)
1185 if(HOSTDATA(shpnt)->debug & debug_eh) {
1186 printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1191 if(CURRENT_SC==SCpnt) {
1192 printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1197 issued = remove_SC(&ISSUE_SC, SCpnt)==0;
1198 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1203 SCpnt->request_buffer = NULL;
1204 SCpnt->request_bufflen = 0;
1207 timer.data = (unsigned long) SCpnt;
1208 timer.expires = jiffies + 100*HZ; /* 10s */
1209 timer.function = (void (*)(unsigned long)) timer_expired;
1211 aha152x_internal_queue(SCpnt, &sem, resetting, reset_done);
1216 SCpnt->cmd_len = SCpnt->old_cmd_len;
1217 SCpnt->use_sg = SCpnt->old_use_sg;
1218 SCpnt->request_buffer = SCpnt->buffer;
1219 SCpnt->request_bufflen = SCpnt->bufflen;
1223 if(SCpnt->SCp.phase & resetted) {
1224 HOSTDATA(shpnt)->commands--;
1225 if (!HOSTDATA(shpnt)->commands)
1227 kfree(SCpnt->host_scribble);
1228 SCpnt->host_scribble=NULL;
1234 append_SC(&ISSUE_SC, SCpnt);
1235 } else if(disconnected) {
1236 append_SC(&DISCONNECTED_SC, SCpnt);
1246 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1257 printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1261 if (!ptr->device->soft_reset) {
1262 DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1263 remove_SC(SCs, ptr);
1264 HOSTDATA(shpnt)->commands--;
1265 kfree(ptr->host_scribble);
1266 ptr->host_scribble=NULL;
1277 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1279 unsigned long flags;
1283 #if defined(AHA152X_DEBUG)
1284 if(HOSTDATA(shpnt)->debug & debug_eh) {
1285 printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1290 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1291 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1293 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1295 SETPORT(SCSISEQ, SCSIRSTO);
1297 SETPORT(SCSISEQ, 0);
1300 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1302 setup_expected_interrupts(shpnt);
1303 if(HOSTDATA(shpnt)->commands==0)
1315 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1317 return aha152x_bus_reset_host(SCpnt->device->host);
1321 * Restore default values to the AIC-6260 registers and reset the fifos
1324 static void reset_ports(struct Scsi_Host *shpnt)
1326 unsigned long flags;
1328 /* disable interrupts */
1329 SETPORT(DMACNTRL0, RSTFIFO);
1331 SETPORT(SCSISEQ, 0);
1333 SETPORT(SXFRCTL1, 0);
1334 SETPORT(SCSISIG, 0);
1337 /* clear all interrupt conditions */
1338 SETPORT(SSTAT0, 0x7f);
1339 SETPORT(SSTAT1, 0xef);
1341 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1343 SETPORT(DMACNTRL0, 0);
1344 SETPORT(DMACNTRL1, 0);
1346 SETPORT(BRSTCNTRL, 0xf1);
1348 /* clear SCSI fifos and transfer count */
1349 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1350 SETPORT(SXFRCTL0, CH1);
1353 setup_expected_interrupts(shpnt);
1358 * Reset the host (bus and controller)
1361 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1363 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1365 aha152x_bus_reset_host(shpnt);
1367 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1374 * Reset the host (bus and controller)
1377 static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1379 return aha152x_host_reset_host(SCpnt->device->host);
1383 * Return the "logical geometry"
1386 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1387 sector_t capacity, int *info_array)
1389 struct Scsi_Host *shpnt = sdev->host;
1391 /* try default translation */
1394 info_array[2] = (unsigned long)capacity / (64 * 32);
1396 /* for disks >1GB do some guessing */
1397 if (info_array[2] >= 1024) {
1400 /* try to figure out the geometry from the partition table */
1401 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1402 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1405 "aha152x: unable to verify geometry for disk with >1GB.\n"
1406 " using extended translation.\n");
1407 info_array[0] = 255;
1409 info_array[2] = (unsigned long)capacity / (255 * 63);
1412 "aha152x: unable to verify geometry for disk with >1GB.\n"
1413 " Using default translation. Please verify yourself.\n"
1414 " Perhaps you need to enable extended translation in the driver.\n"
1415 " See Documentation/scsi/aha152x.txt for details.\n");
1418 info_array[0] = info[0];
1419 info_array[1] = info[1];
1420 info_array[2] = info[2];
1422 if (info[0] == 255 && !EXT_TRANS) {
1424 "aha152x: current partition table is using extended translation.\n"
1425 " using it also, although it's not explicitly enabled.\n");
1434 * Internal done function
1437 static void done(struct Scsi_Host *shpnt, int error)
1441 printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1443 DONE_SC = CURRENT_SC;
1445 DONE_SC->result = error;
1447 printk(KERN_ERR "aha152x: done() called outside of command\n");
1450 static struct work_struct aha152x_tq;
1453 * Run service completions on the card with interrupts enabled.
1456 static void run(void)
1459 for (i = 0; i<ARRAY_SIZE(aha152x_host); i++) {
1460 is_complete(aha152x_host[i]);
1468 static irqreturn_t intr(int irqno, void *dev_id, struct pt_regs *regs)
1470 struct Scsi_Host *shpnt = lookup_irq(irqno);
1471 unsigned long flags;
1472 unsigned char rev, dmacntrl0;
1475 printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno);
1480 * Read a couple of registers that are known to not be all 1's. If
1481 * we read all 1's (-1), that means that either:
1483 * a. The host adapter chip has gone bad, and we cannot control it,
1485 * b. The host adapter is a PCMCIA card that has been ejected
1487 * In either case, we cannot do anything with the host adapter at
1488 * this point in time. So just ignore the interrupt and return.
1489 * In the latter case, the interrupt might actually be meant for
1490 * someone else sharing this IRQ, and that driver will handle it.
1493 dmacntrl0 = GETPORT(DMACNTRL0);
1494 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1497 if( TESTLO(DMASTAT, INTSTAT) )
1500 /* no more interrupts from the controller, while we're busy.
1501 INTEN is restored by the BH handler */
1502 CLRBITS(DMACNTRL0, INTEN);
1505 if( HOSTDATA(shpnt)->service==0 ) {
1506 HOSTDATA(shpnt)->service=1;
1508 /* Poke the BH handler */
1509 INIT_WORK(&aha152x_tq, (void *) run, NULL);
1510 schedule_work(&aha152x_tq);
1519 * - handle completition/disconnection/error of current command
1520 * - start selection for next command (if any)
1522 static void busfree_run(struct Scsi_Host *shpnt)
1524 unsigned long flags;
1525 #if defined(AHA152X_STAT)
1529 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1530 SETPORT(SXFRCTL0, CH1);
1532 SETPORT(SSTAT1, CLRBUSFREE);
1535 #if defined(AHA152X_STAT)
1538 CURRENT_SC->SCp.phase &= ~syncneg;
1540 if(CURRENT_SC->SCp.phase & completed) {
1541 /* target sent COMMAND COMPLETE */
1542 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1544 } else if(CURRENT_SC->SCp.phase & aborted) {
1545 DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1546 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1548 } else if(CURRENT_SC->SCp.phase & resetted) {
1549 DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1550 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1552 } else if(CURRENT_SC->SCp.phase & disconnected) {
1553 /* target sent DISCONNECT */
1554 DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1555 CMDINFO(CURRENT_SC),
1557 CURRENT_SC->request_bufflen);
1558 #if defined(AHA152X_STAT)
1559 HOSTDATA(shpnt)->disconnections++;
1561 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1562 CURRENT_SC->SCp.phase |= 1 << 16;
1566 done(shpnt, DID_ERROR << 16);
1568 #if defined(AHA152X_STAT)
1570 HOSTDATA(shpnt)->busfree_without_old_command++;
1577 #if defined(AHA152X_STAT)
1581 if(DONE_SC->SCp.phase & check_condition) {
1582 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1583 struct aha152x_scdata *sc = SCDATA(cmd);
1586 if(HOSTDATA(shpnt)->debug & debug_eh) {
1587 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1588 scsi_print_sense("bh", DONE_SC);
1592 /* restore old command */
1593 memcpy(cmd->cmnd, sc->cmnd, sizeof(sc->cmnd));
1594 cmd->request_buffer = sc->request_buffer;
1595 cmd->request_bufflen = sc->request_bufflen;
1596 cmd->use_sg = sc->use_sg;
1597 cmd->cmd_len = sc->cmd_len;
1599 cmd->SCp.Status = 0x02;
1601 HOSTDATA(shpnt)->commands--;
1602 if (!HOSTDATA(shpnt)->commands)
1603 SETPORT(PORTA, 0); /* turn led off */
1604 } else if(DONE_SC->SCp.Status==0x02) {
1605 #if defined(AHA152X_STAT)
1606 HOSTDATA(shpnt)->busfree_with_check_condition++;
1609 DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1612 if(!(DONE_SC->SCp.Status & not_issued)) {
1613 Scsi_Cmnd *ptr = DONE_SC;
1616 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1619 ptr->cmnd[0] = REQUEST_SENSE;
1623 ptr->cmnd[4] = sizeof(ptr->sense_buffer);
1627 ptr->request_buffer = ptr->sense_buffer;
1628 ptr->request_bufflen = sizeof(ptr->sense_buffer);
1631 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1635 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1640 if(DONE_SC && DONE_SC->scsi_done) {
1641 #if defined(AHA152X_DEBUG)
1642 int hostno=DONE_SC->device->host->host_no;
1643 int id=DONE_SC->device->id & 0xf;
1644 int lun=DONE_SC->device->lun & 0x7;
1646 Scsi_Cmnd *ptr = DONE_SC;
1649 /* turn led off, when no commands are in the driver */
1650 HOSTDATA(shpnt)->commands--;
1651 if (!HOSTDATA(shpnt)->commands)
1652 SETPORT(PORTA, 0); /* turn led off */
1654 if(ptr->scsi_done != reset_done) {
1655 kfree(ptr->host_scribble);
1656 ptr->host_scribble=NULL;
1660 DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1661 ptr->scsi_done(ptr);
1662 DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1667 #if defined(AHA152X_STAT)
1669 HOSTDATA(shpnt)->busfree_without_done_command++;
1674 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1679 #if defined(AHA152X_STAT)
1682 CURRENT_SC->SCp.phase |= selecting;
1684 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1686 /* clear selection timeout */
1687 SETPORT(SSTAT1, SELTO);
1689 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1690 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1691 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1693 #if defined(AHA152X_STAT)
1694 HOSTDATA(shpnt)->busfree_without_new_command++;
1696 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1699 #if defined(AHA152X_STAT)
1701 HOSTDATA(shpnt)->busfree_without_any_action++;
1706 * Selection done (OUT)
1707 * - queue IDENTIFY message and SDTR to selected target for message out
1708 * (ATN asserted automagically via ENAUTOATNO in busfree())
1710 static void seldo_run(struct Scsi_Host *shpnt)
1712 SETPORT(SCSISIG, 0);
1713 SETPORT(SSTAT1, CLRBUSFREE);
1714 SETPORT(SSTAT1, CLRPHASECHG);
1716 CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1718 SETPORT(SCSISEQ, 0);
1720 if (TESTLO(SSTAT0, SELDO)) {
1721 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1722 done(shpnt, DID_NO_CONNECT << 16);
1726 SETPORT(SSTAT0, CLRSELDO);
1728 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1730 if (CURRENT_SC->SCp.phase & aborting) {
1732 } else if (CURRENT_SC->SCp.phase & resetting) {
1733 ADDMSGO(BUS_DEVICE_RESET);
1734 } else if (SYNCNEG==0 && SYNCHRONOUS) {
1735 CURRENT_SC->SCp.phase |= syncneg;
1736 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1737 SYNCNEG=1; /* negotiation in progress */
1745 * - return command to mid-level with failure cause
1748 static void selto_run(struct Scsi_Host *shpnt)
1750 SETPORT(SCSISEQ, 0);
1751 SETPORT(SSTAT1, CLRSELTIMO);
1753 DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1756 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1760 CURRENT_SC->SCp.phase &= ~selecting;
1762 if (CURRENT_SC->SCp.phase & aborted) {
1763 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1764 done(shpnt, DID_ABORT << 16);
1765 } else if (TESTLO(SSTAT0, SELINGO)) {
1766 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1767 done(shpnt, DID_BUS_BUSY << 16);
1769 /* ARBITRATION won, but SELECTION failed */
1770 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1771 done(shpnt, DID_NO_CONNECT << 16);
1777 * - put current command back to issue queue
1778 * (reconnection of a disconnected nexus instead
1779 * of successful selection out)
1782 static void seldi_run(struct Scsi_Host *shpnt)
1786 unsigned long flags;
1788 SETPORT(SCSISIG, 0);
1789 SETPORT(SSTAT0, CLRSELDI);
1790 SETPORT(SSTAT1, CLRBUSFREE);
1791 SETPORT(SSTAT1, CLRPHASECHG);
1794 if(!(CURRENT_SC->SCp.phase & not_issued))
1795 printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1797 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1800 append_SC(&ISSUE_SC, CURRENT_SC);
1806 if(!DISCONNECTED_SC) {
1807 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1813 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1816 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1820 for(target=7; !(selid & (1 << target)); target--)
1823 if(selid & ~(1 << target)) {
1824 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1829 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1830 SETPORT(SCSISEQ, 0);
1832 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1834 RECONN_TARGET=target;
1835 DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1840 * - handle initial message after reconnection to identify
1841 * reconnecting nexus
1842 * - queue command on DISCONNECTED_SC on DISCONNECT message
1843 * - set completed flag on COMMAND COMPLETE
1844 * (other completition code moved to busfree_run)
1845 * - handle response to SDTR
1846 * - clear synchronous transfer agreements on BUS RESET
1848 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1851 static void msgi_run(struct Scsi_Host *shpnt)
1854 int sstat1 = GETPORT(SSTAT1);
1856 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1859 if(TESTLO(SSTAT0,SPIORDY)) {
1860 DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1864 ADDMSGI(GETPORT(SCSIDAT));
1866 #if defined(AHA152X_DEBUG)
1867 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1868 printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1869 spi_print_msg(&MSGI(0));
1875 if(LASTSTATE!=seldi) {
1876 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1880 * Handle reselection
1882 if(!(MSGI(0) & IDENTIFY_BASE)) {
1883 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1887 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1891 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1895 DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1897 CURRENT_SC->SCp.Message = MSGI(0);
1898 CURRENT_SC->SCp.phase &= ~disconnected;
1902 /* next message if any */
1906 CURRENT_SC->SCp.Message = MSGI(0);
1911 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1913 CURRENT_SC->SCp.phase |= disconnected;
1916 case COMMAND_COMPLETE:
1917 if(CURRENT_SC->SCp.phase & completed)
1918 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1920 CURRENT_SC->SCp.phase |= completed;
1923 case MESSAGE_REJECT:
1925 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1926 SYNCNEG=2; /* negotiation completed */
1928 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1934 case RESTORE_POINTERS:
1937 case EXTENDED_MESSAGE:
1938 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1939 /* not yet completed */
1949 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1953 if (!HOSTDATA(shpnt)->synchronous)
1956 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1957 spi_print_msg(&MSGI(0));
1960 ticks = (MSGI(3) * 4 + 49) / 50;
1963 /* negotiation in progress */
1964 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1965 ADDMSGO(MESSAGE_REJECT);
1966 printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1970 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1971 } else if (ticks <= 9 && MSGI(4) >= 1) {
1972 ADDMSGO(EXTENDED_MESSAGE);
1974 ADDMSGO(EXTENDED_SDTR);
1986 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1988 /* requested SDTR is too slow, do it asynchronously */
1989 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1990 ADDMSGO(MESSAGE_REJECT);
1993 SYNCNEG=2; /* negotiation completed */
1998 case BUS_DEVICE_RESET:
2002 for(i=0; i<8; i++) {
2003 HOSTDATA(shpnt)->syncrate[i]=0;
2004 HOSTDATA(shpnt)->syncneg[i]=0;
2010 case EXTENDED_MODIFY_DATA_POINTER:
2011 case EXTENDED_EXTENDED_IDENTIFY:
2014 ADDMSGO(MESSAGE_REJECT);
2024 static void msgi_end(struct Scsi_Host *shpnt)
2027 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
2029 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
2030 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
2031 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
2039 static void msgo_init(struct Scsi_Host *shpnt)
2042 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2043 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2045 printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2046 ADDMSGO(MESSAGE_REJECT);
2050 #if defined(AHA152X_DEBUG)
2051 if(HOSTDATA(shpnt)->debug & debug_msgo) {
2054 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2055 for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2066 static void msgo_run(struct Scsi_Host *shpnt)
2069 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2071 while(MSGO_I<MSGOLEN) {
2072 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2074 if(TESTLO(SSTAT0, SPIORDY)) {
2075 DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2079 if (MSGO_I==MSGOLEN-1) {
2080 /* Leave MESSAGE OUT after transfer */
2081 SETPORT(SSTAT1, CLRATNO);
2085 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2086 CURRENT_SC->SCp.phase |= identified;
2088 if (MSGO(MSGO_I)==ABORT)
2089 CURRENT_SC->SCp.phase |= aborted;
2091 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2092 CURRENT_SC->SCp.phase |= resetted;
2094 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2098 static void msgo_end(struct Scsi_Host *shpnt)
2100 if(MSGO_I<MSGOLEN) {
2101 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2103 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2116 static void cmd_init(struct Scsi_Host *shpnt)
2118 if (CURRENT_SC->SCp.sent_command) {
2119 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2120 done(shpnt, DID_ERROR << 16);
2124 #if defined(AHA152X_DEBUG)
2125 if (HOSTDATA(shpnt)->debug & debug_cmd) {
2126 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2127 __scsi_print_command(CURRENT_SC->cmnd);
2138 static void cmd_run(struct Scsi_Host *shpnt)
2140 if(CMD_I==CURRENT_SC->cmd_len) {
2141 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2145 while(CMD_I<CURRENT_SC->cmd_len) {
2146 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);
2148 if(TESTLO(SSTAT0, SPIORDY)) {
2149 DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2153 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2157 static void cmd_end(struct Scsi_Host *shpnt)
2159 if(CMD_I<CURRENT_SC->cmd_len)
2160 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2162 CURRENT_SC->SCp.sent_command++;
2169 static void status_run(struct Scsi_Host *shpnt)
2171 if(TESTLO(SSTAT0,SPIORDY)) {
2172 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2176 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2178 #if defined(AHA152X_DEBUG)
2179 if (HOSTDATA(shpnt)->debug & debug_status) {
2180 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2181 scsi_print_status(CURRENT_SC->SCp.Status);
2191 static void datai_init(struct Scsi_Host *shpnt)
2193 SETPORT(DMACNTRL0, RSTFIFO);
2194 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2196 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2197 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2199 SETPORT(SIMODE0, 0);
2200 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2203 DPRINTK(debug_datai,
2204 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2205 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2208 static void datai_run(struct Scsi_Host *shpnt)
2210 unsigned long the_time;
2211 int fifodata, data_count;
2214 * loop while the phase persists or the fifos are not empty
2217 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2218 /* FIXME: maybe this should be done by setting up
2219 * STCNT to trigger ENSWRAP interrupt, instead of
2220 * polling for DFIFOFULL
2222 the_time=jiffies + 100*HZ;
2223 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2226 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2227 printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2232 if(TESTHI(DMASTAT, DFIFOFULL)) {
2235 the_time=jiffies + 100*HZ;
2236 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2239 if(TESTLO(SSTAT2, SEMPTY)) {
2240 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2245 fifodata = GETPORT(FIFOSTAT);
2248 if(CURRENT_SC->SCp.this_residual>0) {
2249 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2250 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2251 CURRENT_SC->SCp.this_residual :
2253 fifodata -= data_count;
2255 if(data_count & 1) {
2256 DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2257 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2258 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2259 CURRENT_SC->SCp.this_residual--;
2261 SETPORT(DMACNTRL0, ENDMA);
2264 if(data_count > 1) {
2265 DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2267 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2268 CURRENT_SC->SCp.ptr += 2 * data_count;
2269 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2270 DATA_LEN += 2 * data_count;
2273 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2274 /* advance to next buffer */
2275 CURRENT_SC->SCp.buffers_residual--;
2276 CURRENT_SC->SCp.buffer++;
2277 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2278 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2281 } else if(fifodata>0) {
2282 printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2283 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2286 data=GETPORT(DATAPORT);
2287 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2291 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2295 if(TESTLO(DMASTAT, INTSTAT) ||
2296 TESTLO(DMASTAT, DFIFOEMP) ||
2297 TESTLO(SSTAT2, SEMPTY) ||
2298 GETPORT(FIFOSTAT)>0) {
2300 * something went wrong, if there's something left in the fifos
2301 * or the phase didn't change
2303 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2307 if(DATA_LEN!=GETSTCNT()) {
2309 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2310 CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2316 static void datai_end(struct Scsi_Host *shpnt)
2318 CURRENT_SC->resid -= GETSTCNT();
2320 DPRINTK(debug_datai,
2321 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2322 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid, GETSTCNT());
2324 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2325 SETPORT(DMACNTRL0, 0);
2332 static void datao_init(struct Scsi_Host *shpnt)
2334 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2335 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2337 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2338 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2340 SETPORT(SIMODE0, 0);
2341 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2343 DATA_LEN = CURRENT_SC->resid;
2345 DPRINTK(debug_datao,
2346 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2347 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2350 static void datao_run(struct Scsi_Host *shpnt)
2352 unsigned long the_time;
2355 /* until phase changes or all data sent */
2356 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2358 if(data_count > CURRENT_SC->SCp.this_residual)
2359 data_count=CURRENT_SC->SCp.this_residual;
2361 if(TESTLO(DMASTAT, DFIFOEMP)) {
2362 printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2367 if(data_count & 1) {
2368 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2369 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2370 CURRENT_SC->SCp.this_residual--;
2371 CURRENT_SC->resid--;
2372 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2375 if(data_count > 1) {
2377 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2378 CURRENT_SC->SCp.ptr += 2 * data_count;
2379 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2380 CURRENT_SC->resid -= 2 * data_count;
2383 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2384 /* advance to next buffer */
2385 CURRENT_SC->SCp.buffers_residual--;
2386 CURRENT_SC->SCp.buffer++;
2387 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2388 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2391 the_time=jiffies + 100*HZ;
2392 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2395 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2396 printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2403 static void datao_end(struct Scsi_Host *shpnt)
2405 if(TESTLO(DMASTAT, DFIFOEMP)) {
2406 int data_count = (DATA_LEN - CURRENT_SC->resid) - GETSTCNT();
2408 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2409 CMDINFO(CURRENT_SC),
2411 DATA_LEN-CURRENT_SC->resid,
2414 CURRENT_SC->resid += data_count;
2416 if(CURRENT_SC->use_sg) {
2417 data_count -= CURRENT_SC->SCp.ptr - SG_ADDRESS(CURRENT_SC->SCp.buffer);
2418 while(data_count>0) {
2419 CURRENT_SC->SCp.buffer--;
2420 CURRENT_SC->SCp.buffers_residual++;
2421 data_count -= CURRENT_SC->SCp.buffer->length;
2423 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) - data_count;
2424 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + data_count;
2426 CURRENT_SC->SCp.ptr -= data_count;
2427 CURRENT_SC->SCp.this_residual += data_count;
2431 DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2432 CMDINFO(CURRENT_SC),
2433 CURRENT_SC->request_bufflen,
2437 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2438 SETPORT(SXFRCTL0, CH1);
2440 SETPORT(DMACNTRL0, 0);
2444 * figure out what state we're in
2447 static int update_state(struct Scsi_Host *shpnt)
2450 unsigned int stat0 = GETPORT(SSTAT0);
2451 unsigned int stat1 = GETPORT(SSTAT1);
2456 if(stat1 & SCSIRSTI) {
2459 SETPORT(SSTAT1,SCSIRSTI);
2460 } else if(stat0 & SELDI && PREVSTATE==busfree) {
2462 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2464 } else if(stat1 & SELTO) {
2466 } else if(stat1 & BUSFREE) {
2468 SETPORT(SSTAT1,BUSFREE);
2469 } else if(stat1 & SCSIPERR) {
2471 SETPORT(SSTAT1,SCSIPERR);
2472 } else if(stat1 & REQINIT) {
2473 switch(GETPORT(SCSISIG) & P_MASK) {
2474 case P_MSGI: STATE=msgi; break;
2475 case P_MSGO: STATE=msgo; break;
2476 case P_DATAO: STATE=datao; break;
2477 case P_DATAI: STATE=datai; break;
2478 case P_STATUS: STATE=status; break;
2479 case P_CMD: STATE=cmd; break;
2484 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2485 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2489 if(STATE!=PREVSTATE) {
2490 LASTSTATE=PREVSTATE;
2497 * handle parity error
2499 * FIXME: in which phase?
2502 static void parerr_run(struct Scsi_Host *shpnt)
2504 printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2505 done(shpnt, DID_PARITY << 16);
2512 static void rsti_run(struct Scsi_Host *shpnt)
2516 printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2518 ptr=DISCONNECTED_SC;
2520 Scsi_Cmnd *next = SCNEXT(ptr);
2522 if (!ptr->device->soft_reset) {
2523 remove_SC(&DISCONNECTED_SC, ptr);
2525 kfree(ptr->host_scribble);
2526 ptr->host_scribble=NULL;
2528 ptr->result = DID_RESET << 16;
2529 ptr->scsi_done(ptr);
2535 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2536 done(shpnt, DID_RESET << 16 );
2541 * bottom-half handler
2544 static void is_complete(struct Scsi_Host *shpnt)
2547 unsigned long flags;
2555 if( HOSTDATA(shpnt)->service==0 ) {
2560 HOSTDATA(shpnt)->service = 0;
2562 if(HOSTDATA(shpnt)->in_intr) {
2564 /* aha152x_error never returns.. */
2565 aha152x_error(shpnt, "bottom-half already running!?");
2567 HOSTDATA(shpnt)->in_intr++;
2570 * loop while there are interrupt conditions pending
2574 unsigned long start = jiffies;
2577 dataphase=update_state(shpnt);
2579 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2582 * end previous state
2585 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2586 states[PREVSTATE].end(shpnt);
2589 * disable SPIO mode if previous phase used it
2590 * and this one doesn't
2593 if(states[PREVSTATE].spio && !states[STATE].spio) {
2594 SETPORT(SXFRCTL0, CH1);
2595 SETPORT(DMACNTRL0, 0);
2597 CURRENT_SC->SCp.phase &= ~spiordy;
2601 * accept current dataphase phase
2605 SETPORT(SSTAT0, REQINIT);
2606 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2607 SETPORT(SSTAT1, PHASECHG);
2611 * enable SPIO mode if previous didn't use it
2615 if(!states[PREVSTATE].spio && states[STATE].spio) {
2616 SETPORT(DMACNTRL0, 0);
2617 SETPORT(SXFRCTL0, CH1|SPIOEN);
2619 CURRENT_SC->SCp.phase |= spiordy;
2623 * initialize for new state
2626 if(PREVSTATE!=STATE && states[STATE].init)
2627 states[STATE].init(shpnt);
2630 * handle current state
2633 if(states[STATE].run)
2634 states[STATE].run(shpnt);
2636 printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2639 * setup controller to interrupt on
2640 * the next expected condition and
2641 * loop if it's already there
2645 pending=setup_expected_interrupts(shpnt);
2646 #if defined(AHA152X_STAT)
2647 HOSTDATA(shpnt)->count[STATE]++;
2648 if(PREVSTATE!=STATE)
2649 HOSTDATA(shpnt)->count_trans[STATE]++;
2650 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2653 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2657 * enable interrupts and leave bottom-half
2660 HOSTDATA(shpnt)->in_intr--;
2661 SETBITS(DMACNTRL0, INTEN);
2667 * Dump the current driver status and panic
2669 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2671 printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2673 panic("aha152x panic\n");
2677 * Display registers of AIC-6260
2679 static void disp_ports(struct Scsi_Host *shpnt)
2681 #if defined(AHA152X_DEBUG)
2684 printk("\n%s: %s(%s) ",
2685 CURRENT_SC ? "busy" : "waiting",
2687 states[PREVSTATE].name);
2689 s = GETPORT(SCSISEQ);
2690 printk("SCSISEQ( ");
2692 printk("TARGET MODE ");
2700 printk("AUTOATNO ");
2702 printk("AUTOATNI ");
2704 printk("AUTOATNP ");
2706 printk("SCSIRSTO ");
2709 printk(" SCSISIG(");
2710 s = GETPORT(SCSISIG);
2711 switch (s & P_MASK) {
2725 printk("MESSAGE OUT");
2728 printk("MESSAGE IN");
2731 printk("*invalid*");
2737 printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2740 s = GETPORT(SSTAT0);
2758 s = GETPORT(SSTAT1);
2764 printk("SCSIRSTI ");
2766 printk("PHASEMIS ");
2770 printk("SCSIPERR ");
2772 printk("PHASECHG ");
2780 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2799 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2806 printk("SCSIRSTI ");
2808 printk("PHASEMIS ");
2812 printk("SCSIPERR ");
2814 printk("PHASECHG ");
2819 printk("SXFRCTL0( ");
2821 s = GETPORT(SXFRCTL0);
2829 printk("CLRSTCNT ");
2838 s = GETPORT(SCSISIG);
2851 printk("SELID (%02x), ", GETPORT(SELID));
2853 printk("STCNT (%d), ", GETSTCNT());
2857 s = GETPORT(SSTAT2);
2864 printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2866 s = GETPORT(SSTAT3);
2867 printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2870 s = GETPORT(SSTAT4);
2879 printk("DMACNTRL0( ");
2880 s = GETPORT(DMACNTRL0);
2881 printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2882 printk("%s ", s & DMA ? "DMA" : "PIO");
2883 printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2894 printk("DMASTAT( ");
2895 s = GETPORT(DMASTAT);
2901 printk("DFIFOFULL ");
2903 printk("DFIFOEMP ");
2909 * display enabled interrupts
2911 static void disp_enintr(struct Scsi_Host *shpnt)
2915 printk(KERN_DEBUG "enabled interrupts ( ");
2917 s = GETPORT(SIMODE0);
2923 printk("ENSELINGO ");
2929 printk("ENSPIORDY ");
2931 printk("ENDMADONE ");
2933 s = GETPORT(SIMODE1);
2935 printk("ENSELTIMO ");
2937 printk("ENATNTARG ");
2939 printk("ENPHASEMIS ");
2941 printk("ENBUSFREE ");
2943 printk("ENSCSIPERR ");
2945 printk("ENPHASECHG ");
2947 printk("ENREQINIT ");
2952 * Show the command data of a command
2954 static void show_command(Scsi_Cmnd *ptr)
2956 scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2958 __scsi_print_command(ptr->cmnd);
2960 printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2961 ptr->request_bufflen, ptr->resid);
2963 if (ptr->SCp.phase & not_issued)
2964 printk("not issued|");
2965 if (ptr->SCp.phase & selecting)
2966 printk("selecting|");
2967 if (ptr->SCp.phase & identified)
2968 printk("identified|");
2969 if (ptr->SCp.phase & disconnected)
2970 printk("disconnected|");
2971 if (ptr->SCp.phase & completed)
2972 printk("completed|");
2973 if (ptr->SCp.phase & spiordy)
2975 if (ptr->SCp.phase & syncneg)
2977 if (ptr->SCp.phase & aborted)
2979 if (ptr->SCp.phase & resetted)
2980 printk("resetted|");
2982 printk("; next=0x%p\n", SCNEXT(ptr));
2984 printk("; next=(host scribble NULL)\n");
2989 * Dump the queued data
2991 static void show_queues(struct Scsi_Host *shpnt)
2994 unsigned long flags;
2997 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2998 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3002 printk(KERN_DEBUG "current_SC:\n");
3004 show_command(CURRENT_SC);
3006 printk(KERN_DEBUG "none\n");
3008 printk(KERN_DEBUG "disconnected_SC:\n");
3009 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
3017 #define SPRINTF(args...) pos += sprintf(pos, ## args)
3019 static int get_command(char *pos, Scsi_Cmnd * ptr)
3024 SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
3025 (unsigned int) ptr, ptr->device->id, ptr->device->lun);
3027 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
3028 SPRINTF("0x%02x ", ptr->cmnd[i]);
3030 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
3031 ptr->resid, ptr->SCp.this_residual, ptr->SCp.buffers_residual);
3033 if (ptr->SCp.phase & not_issued)
3034 SPRINTF("not issued|");
3035 if (ptr->SCp.phase & selecting)
3036 SPRINTF("selecting|");
3037 if (ptr->SCp.phase & disconnected)
3038 SPRINTF("disconnected|");
3039 if (ptr->SCp.phase & aborted)
3040 SPRINTF("aborted|");
3041 if (ptr->SCp.phase & identified)
3042 SPRINTF("identified|");
3043 if (ptr->SCp.phase & completed)
3044 SPRINTF("completed|");
3045 if (ptr->SCp.phase & spiordy)
3046 SPRINTF("spiordy|");
3047 if (ptr->SCp.phase & syncneg)
3048 SPRINTF("syncneg|");
3049 SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3051 return (pos - start);
3054 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3059 SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3061 s = GETPORT(SCSISEQ);
3062 SPRINTF("SCSISEQ( ");
3064 SPRINTF("TARGET MODE ");
3072 SPRINTF("AUTOATNO ");
3074 SPRINTF("AUTOATNI ");
3076 SPRINTF("AUTOATNP ");
3078 SPRINTF("SCSIRSTO ");
3081 SPRINTF(" SCSISIG(");
3082 s = GETPORT(SCSISIG);
3083 switch (s & P_MASK) {
3085 SPRINTF("DATA OUT");
3097 SPRINTF("MESSAGE OUT");
3100 SPRINTF("MESSAGE IN");
3103 SPRINTF("*invalid*");
3109 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3112 s = GETPORT(SSTAT0);
3120 SPRINTF("SELINGO ");
3126 SPRINTF("SPIORDY ");
3128 SPRINTF("DMADONE ");
3130 s = GETPORT(SSTAT1);
3134 SPRINTF("ATNTARG ");
3136 SPRINTF("SCSIRSTI ");
3138 SPRINTF("PHASEMIS ");
3140 SPRINTF("BUSFREE ");
3142 SPRINTF("SCSIPERR ");
3144 SPRINTF("PHASECHG ");
3146 SPRINTF("REQINIT ");
3152 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3161 SPRINTF("SELINGO ");
3167 SPRINTF("SPIORDY ");
3169 SPRINTF("DMADONE ");
3171 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3176 SPRINTF("ATNTARG ");
3178 SPRINTF("SCSIRSTI ");
3180 SPRINTF("PHASEMIS ");
3182 SPRINTF("BUSFREE ");
3184 SPRINTF("SCSIPERR ");
3186 SPRINTF("PHASECHG ");
3188 SPRINTF("REQINIT ");
3191 SPRINTF("SXFRCTL0( ");
3193 s = GETPORT(SXFRCTL0);
3201 SPRINTF("CLRSTCNT ");
3208 SPRINTF("SIGNAL( ");
3210 s = GETPORT(SCSISIG);
3223 SPRINTF("SELID(%02x), ", GETPORT(SELID));
3225 SPRINTF("STCNT(%d), ", GETSTCNT());
3227 SPRINTF("SSTAT2( ");
3229 s = GETPORT(SSTAT2);
3231 SPRINTF("SOFFSET ");
3236 SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3238 s = GETPORT(SSTAT3);
3239 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3241 SPRINTF("SSTAT4( ");
3242 s = GETPORT(SSTAT4);
3244 SPRINTF("SYNCERR ");
3251 SPRINTF("DMACNTRL0( ");
3252 s = GETPORT(DMACNTRL0);
3253 SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3254 SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3255 SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3261 SPRINTF("RSTFIFO ");
3266 SPRINTF("DMASTAT( ");
3267 s = GETPORT(DMASTAT);
3271 SPRINTF("WORDRDY ");
3273 SPRINTF("DFIFOFULL ");
3275 SPRINTF("DFIFOEMP ");
3278 SPRINTF("enabled interrupts( ");
3280 s = GETPORT(SIMODE0);
3282 SPRINTF("ENSELDO ");
3284 SPRINTF("ENSELDI ");
3286 SPRINTF("ENSELINGO ");
3288 SPRINTF("ENSWRAP ");
3290 SPRINTF("ENSDONE ");
3292 SPRINTF("ENSPIORDY ");
3294 SPRINTF("ENDMADONE ");
3296 s = GETPORT(SIMODE1);
3298 SPRINTF("ENSELTIMO ");
3300 SPRINTF("ENATNTARG ");
3302 SPRINTF("ENPHASEMIS ");
3304 SPRINTF("ENBUSFREE ");
3306 SPRINTF("ENSCSIPERR ");
3308 SPRINTF("ENPHASECHG ");
3310 SPRINTF("ENREQINIT ");
3313 return (pos - start);
3316 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3318 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3321 #if defined(AHA152X_DEBUG)
3322 if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3323 int debug = HOSTDATA(shpnt)->debug;
3325 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3327 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3330 #if defined(AHA152X_STAT)
3331 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3334 HOSTDATA(shpnt)->total_commands=0;
3335 HOSTDATA(shpnt)->disconnections=0;
3336 HOSTDATA(shpnt)->busfree_without_any_action=0;
3337 HOSTDATA(shpnt)->busfree_without_old_command=0;
3338 HOSTDATA(shpnt)->busfree_without_new_command=0;
3339 HOSTDATA(shpnt)->busfree_without_done_command=0;
3340 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3341 for (i = idle; i<maxstate; i++) {
3342 HOSTDATA(shpnt)->count[i]=0;
3343 HOSTDATA(shpnt)->count_trans[i]=0;
3344 HOSTDATA(shpnt)->time[i]=0;
3347 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3360 #define SPRINTF(args...) \
3361 do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3363 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3364 off_t offset, int length, int inout)
3369 unsigned long flags;
3372 DPRINTK(debug_procinfo,
3373 KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3374 buffer, offset, length, shpnt->host_no, inout);
3378 return aha152x_set_info(buffer, length, shpnt);
3380 SPRINTF(AHA152X_REVID "\n");
3382 SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3383 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3384 SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3385 SPRINTF("disconnection/reconnection %s\n",
3386 RECONNECT ? "enabled" : "disabled");
3387 SPRINTF("parity checking %s\n",
3388 PARITY ? "enabled" : "disabled");
3389 SPRINTF("synchronous transfers %s\n",
3390 SYNCHRONOUS ? "enabled" : "disabled");
3391 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3394 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3395 for (i = 0; i < 8; i++)
3396 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3397 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3399 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3400 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3401 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3403 #if defined(AHA152X_DEBUG)
3404 #define PDEBUG(flags,txt) \
3405 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3407 SPRINTF("enabled debugging options: ");
3409 PDEBUG(debug_procinfo, "procinfo");
3410 PDEBUG(debug_queue, "queue");
3411 PDEBUG(debug_intr, "interrupt");
3412 PDEBUG(debug_selection, "selection");
3413 PDEBUG(debug_msgo, "message out");
3414 PDEBUG(debug_msgi, "message in");
3415 PDEBUG(debug_status, "status");
3416 PDEBUG(debug_cmd, "command");
3417 PDEBUG(debug_datai, "data in");
3418 PDEBUG(debug_datao, "data out");
3419 PDEBUG(debug_eh, "eh");
3420 PDEBUG(debug_locks, "locks");
3421 PDEBUG(debug_phases, "phases");
3426 SPRINTF("\nqueue status:\n");
3429 SPRINTF("not yet issued commands:\n");
3430 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3431 pos += get_command(pos, ptr);
3433 SPRINTF("no not yet issued commands\n");
3437 SPRINTF("current command:\n");
3438 pos += get_command(pos, CURRENT_SC);
3440 SPRINTF("no current command\n");
3442 if (DISCONNECTED_SC) {
3443 SPRINTF("disconnected commands:\n");
3444 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3445 pos += get_command(pos, ptr);
3447 SPRINTF("no disconnected commands\n");
3449 pos += get_ports(shpnt, pos);
3451 #if defined(AHA152X_STAT)
3452 SPRINTF("statistics:\n"
3453 "total commands: %d\n"
3454 "disconnections: %d\n"
3455 "busfree with check condition: %d\n"
3456 "busfree without old command: %d\n"
3457 "busfree without new command: %d\n"
3458 "busfree without done command: %d\n"
3459 "busfree without any action: %d\n"
3464 HOSTDATA(shpnt)->total_commands,
3465 HOSTDATA(shpnt)->disconnections,
3466 HOSTDATA(shpnt)->busfree_with_check_condition,
3467 HOSTDATA(shpnt)->busfree_without_old_command,
3468 HOSTDATA(shpnt)->busfree_without_new_command,
3469 HOSTDATA(shpnt)->busfree_without_done_command,
3470 HOSTDATA(shpnt)->busfree_without_any_action);
3471 for(i=0; i<maxstate; i++) {
3472 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3474 HOSTDATA(shpnt)->count_trans[i],
3475 HOSTDATA(shpnt)->count[i],
3476 HOSTDATA(shpnt)->time[i]);
3480 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3482 thislength = pos - (buffer + offset);
3483 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3486 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3491 thislength = thislength<length ? thislength : length;
3493 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3495 *start = buffer + offset;
3496 return thislength < length ? thislength : length;
3499 static struct scsi_host_template aha152x_driver_template = {
3500 .module = THIS_MODULE,
3501 .name = AHA152X_REVID,
3502 .proc_name = "aha152x",
3503 .proc_info = aha152x_proc_info,
3504 .queuecommand = aha152x_queue,
3505 .eh_abort_handler = aha152x_abort,
3506 .eh_device_reset_handler = aha152x_device_reset,
3507 .eh_bus_reset_handler = aha152x_bus_reset,
3508 .eh_host_reset_handler = aha152x_host_reset,
3509 .bios_param = aha152x_biosparam,
3512 .sg_tablesize = SG_ALL,
3514 .use_clustering = DISABLE_CLUSTERING,
3517 #if !defined(PCMCIA)
3518 static int setup_count;
3519 static struct aha152x_setup setup[2];
3521 /* possible i/o addresses for the AIC-6260; default first */
3522 static unsigned short ports[] = { 0x340, 0x140 };
3524 #if !defined(SKIP_BIOSTEST)
3525 /* possible locations for the Adaptec BIOS; defaults first */
3526 static unsigned int addresses[] =
3528 0xdc000, /* default first */
3535 0xeb800, /* VTech Platinum SMP */
3539 /* signatures for various AIC-6[23]60 based controllers.
3540 The point in detecting signatures is to avoid useless and maybe
3541 harmful probes on ports. I'm not sure that all listed boards pass
3542 auto-configuration. For those which fail the BIOS signature is
3543 obsolete, because user intervention to supply the configuration is
3544 needed anyway. May be an information whether or not the BIOS supports
3545 extended translation could be also useful here. */
3546 static struct signature {
3547 unsigned char *signature;
3552 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3554 { "Adaptec AHA-1520B", 0x000b, 17 },
3555 /* Adaptec 152x rev B */
3556 { "Adaptec AHA-1520B", 0x0026, 17 },
3557 /* Iomega Jaz Jet ISA (AIC6370Q) */
3558 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3559 /* on-board controller */
3560 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3561 /* on-board controller */
3562 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3563 /* on-board controller */
3564 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3565 /* on-board controller */
3566 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3567 /* ScsiPro-Controller */
3568 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3569 /* Gigabyte Local-Bus-SCSI */
3570 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3572 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3573 /* IBM Thinkpad Dock II */
3574 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3575 /* IBM Thinkpad Dock II SCSI */
3576 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3577 /* DTC 3520A ISA SCSI */
3579 #endif /* !SKIP_BIOSTEST */
3582 * Test, if port_base is valid.
3585 static int aha152x_porttest(int io_port)
3589 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3590 for (i = 0; i < 16; i++)
3591 SETPORT(io_port + O_STACK, i);
3593 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3594 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3600 static int tc1550_porttest(int io_port)
3604 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3605 for (i = 0; i < 16; i++)
3606 SETPORT(io_port + O_STACK, i);
3608 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3609 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3616 static int checksetup(struct aha152x_setup *setup)
3619 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3622 if (i == ARRAY_SIZE(ports))
3625 if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) {
3626 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3630 if( aha152x_porttest(setup->io_port) ) {
3632 } else if( tc1550_porttest(setup->io_port) ) {
3635 release_region(setup->io_port, IO_RANGE);
3639 release_region(setup->io_port, IO_RANGE);
3641 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3644 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3647 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3650 if ((setup->parity < 0) || (setup->parity > 1))
3653 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3656 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3664 static int __init aha152x_init(void)
3667 #if defined(AUTOCONF)
3668 aha152x_config conf;
3671 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3674 if ( setup_count ) {
3675 printk(KERN_INFO "aha152x: processing commandline: ");
3677 for (i = 0; i<setup_count; i++) {
3678 if (!checksetup(&setup[i])) {
3679 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3680 printk(KERN_ERR "aha152x: invalid line\n");
3687 if (setup_count < ARRAY_SIZE(setup)) {
3688 struct aha152x_setup override = SETUP0;
3690 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3691 if (!checksetup(&override)) {
3692 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3698 override.synchronous,
3700 override.ext_trans);
3702 setup[setup_count++] = override;
3708 if (setup_count < ARRAY_SIZE(setup)) {
3709 struct aha152x_setup override = SETUP1;
3711 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3712 if (!checksetup(&override)) {
3713 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3719 override.synchronous,
3721 override.ext_trans);
3723 setup[setup_count++] = override;
3729 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3731 setup[setup_count].conf = "";
3732 setup[setup_count].io_port = aha152x[0];
3733 setup[setup_count].irq = aha152x[1];
3734 setup[setup_count].scsiid = aha152x[2];
3735 setup[setup_count].reconnect = aha152x[3];
3736 setup[setup_count].parity = aha152x[4];
3737 setup[setup_count].synchronous = aha152x[5];
3738 setup[setup_count].delay = aha152x[6];
3739 setup[setup_count].ext_trans = aha152x[7];
3740 #if defined(AHA152X_DEBUG)
3741 setup[setup_count].debug = aha152x[8];
3743 } else if(io[0]!=0 || irq[0]!=0) {
3744 if(io[0]!=0) setup[setup_count].io_port = io[0];
3745 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3747 setup[setup_count].scsiid = scsiid[0];
3748 setup[setup_count].reconnect = reconnect[0];
3749 setup[setup_count].parity = parity[0];
3750 setup[setup_count].synchronous = sync[0];
3751 setup[setup_count].delay = delay[0];
3752 setup[setup_count].ext_trans = exttrans[0];
3753 #if defined(AHA152X_DEBUG)
3754 setup[setup_count].debug = debug[0];
3758 if (checksetup(&setup[setup_count]))
3761 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",
3762 setup[setup_count].io_port,
3763 setup[setup_count].irq,
3764 setup[setup_count].scsiid,
3765 setup[setup_count].reconnect,
3766 setup[setup_count].parity,
3767 setup[setup_count].synchronous,
3768 setup[setup_count].delay,
3769 setup[setup_count].ext_trans);
3772 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3773 if(aha152x1[0]!=0) {
3774 setup[setup_count].conf = "";
3775 setup[setup_count].io_port = aha152x1[0];
3776 setup[setup_count].irq = aha152x1[1];
3777 setup[setup_count].scsiid = aha152x1[2];
3778 setup[setup_count].reconnect = aha152x1[3];
3779 setup[setup_count].parity = aha152x1[4];
3780 setup[setup_count].synchronous = aha152x1[5];
3781 setup[setup_count].delay = aha152x1[6];
3782 setup[setup_count].ext_trans = aha152x1[7];
3783 #if defined(AHA152X_DEBUG)
3784 setup[setup_count].debug = aha152x1[8];
3786 } else if(io[1]!=0 || irq[1]!=0) {
3787 if(io[1]!=0) setup[setup_count].io_port = io[1];
3788 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3790 setup[setup_count].scsiid = scsiid[1];
3791 setup[setup_count].reconnect = reconnect[1];
3792 setup[setup_count].parity = parity[1];
3793 setup[setup_count].synchronous = sync[1];
3794 setup[setup_count].delay = delay[1];
3795 setup[setup_count].ext_trans = exttrans[1];
3796 #if defined(AHA152X_DEBUG)
3797 setup[setup_count].debug = debug[1];
3800 if (checksetup(&setup[setup_count]))
3803 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",
3804 setup[setup_count].io_port,
3805 setup[setup_count].irq,
3806 setup[setup_count].scsiid,
3807 setup[setup_count].reconnect,
3808 setup[setup_count].parity,
3809 setup[setup_count].synchronous,
3810 setup[setup_count].delay,
3811 setup[setup_count].ext_trans);
3816 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3817 while ( setup_count<ARRAY_SIZE(setup) &&
3818 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3819 if (pnp_device_attach(dev) < 0)
3822 if (pnp_activate_dev(dev) < 0) {
3823 pnp_device_detach(dev);
3827 if (!pnp_port_valid(dev, 0)) {
3828 pnp_device_detach(dev);
3832 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3833 pnp_device_detach(dev);
3837 setup[setup_count].io_port = pnp_port_start(dev, 0);
3838 setup[setup_count].irq = pnp_irq(dev, 0);
3839 setup[setup_count].scsiid = 7;
3840 setup[setup_count].reconnect = 1;
3841 setup[setup_count].parity = 1;
3842 setup[setup_count].synchronous = 1;
3843 setup[setup_count].delay = DELAY_DEFAULT;
3844 setup[setup_count].ext_trans = 0;
3845 #if defined(AHA152X_DEBUG)
3846 setup[setup_count].debug = DEBUG_DEFAULT;
3848 #if defined(__ISAPNP__)
3849 pnpdev[setup_count] = dev;
3852 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3853 setup[setup_count].io_port, setup[setup_count].irq);
3859 #if defined(AUTOCONF)
3860 if (setup_count<ARRAY_SIZE(setup)) {
3861 #if !defined(SKIP_BIOSTEST)
3863 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3864 void __iomem *p = ioremap(addresses[i], 0x4000);
3867 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3868 ok = check_signature(p + signatures[j].sig_offset,
3869 signatures[j].signature, signatures[j].sig_length);
3872 if (!ok && setup_count == 0)
3875 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3877 printk(KERN_INFO "aha152x: ");
3878 #endif /* !SKIP_BIOSTEST */
3881 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3882 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3885 if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) {
3886 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3890 if (aha152x_porttest(ports[i])) {
3891 setup[setup_count].tc1550 = 0;
3894 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3895 } else if (tc1550_porttest(ports[i])) {
3896 setup[setup_count].tc1550 = 1;
3899 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3901 release_region(ports[i], IO_RANGE);
3905 release_region(ports[i], IO_RANGE);
3908 setup[setup_count].io_port = ports[i];
3909 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3910 setup[setup_count].scsiid = conf.cf_id;
3911 setup[setup_count].reconnect = conf.cf_tardisc;
3912 setup[setup_count].parity = !conf.cf_parity;
3913 setup[setup_count].synchronous = conf.cf_syncneg;
3914 setup[setup_count].delay = DELAY_DEFAULT;
3915 setup[setup_count].ext_trans = 0;
3916 #if defined(AHA152X_DEBUG)
3917 setup[setup_count].debug = DEBUG_DEFAULT;
3924 printk("auto configuration: ok, ");
3928 printk("%d controller(s) configured\n", setup_count);
3930 for (i=0; i<setup_count; i++) {
3931 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3932 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3935 release_region(setup[i].io_port, IO_RANGE);
3936 #if defined(__ISAPNP__)
3937 } else if( pnpdev[i] ) {
3938 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3943 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3946 #if defined(__ISAPNP__)
3948 pnp_device_detach(pnpdev[i]);
3952 return registered_count>0;
3955 static void __exit aha152x_exit(void)
3959 for(i=0; i<ARRAY_SIZE(setup); i++) {
3960 aha152x_release(aha152x_host[i]);
3961 aha152x_host[i]=NULL;
3965 module_init(aha152x_init);
3966 module_exit(aha152x_exit);
3968 #if !defined(MODULE)
3969 static int __init aha152x_setup(char *str)
3971 #if defined(AHA152X_DEBUG)
3976 get_options(str, ARRAY_SIZE(ints), ints);
3978 if(setup_count>=ARRAY_SIZE(setup)) {
3979 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3983 setup[setup_count].conf = str;
3984 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3985 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3986 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3987 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3988 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3989 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3990 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3991 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3992 #if defined(AHA152X_DEBUG)
3993 setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3995 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3996 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3998 if (ints[0] > 8) { /*}*/
3999 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
4000 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
4009 __setup("aha152x=", aha152x_setup);
4012 #endif /* !PCMCIA */