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>
265 static LIST_HEAD(aha152x_host_list);
270 /* For PCMCIA cards, always use AUTOCONF */
271 #if defined(PCMCIA) || defined(MODULE)
272 #if !defined(AUTOCONF)
277 #if !defined(AUTOCONF) && !defined(SETUP0)
278 #error define AUTOCONF or SETUP0
281 #if defined(AHA152X_DEBUG)
282 #define DEBUG_DEFAULT debug_eh
284 #define DPRINTK(when,msgs...) \
285 do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
287 #define DO_LOCK(flags) \
289 if(spin_is_locked(&QLOCK)) { \
290 DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
292 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
293 spin_lock_irqsave(&QLOCK,flags); \
294 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
295 QLOCKER=__FUNCTION__; \
299 #define DO_UNLOCK(flags) \
301 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
302 spin_unlock_irqrestore(&QLOCK,flags); \
303 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
304 QLOCKER="(not locked)"; \
309 #define DPRINTK(when,msgs...)
310 #define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
311 #define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
314 #define LEAD "(scsi%d:%d:%d) "
315 #define WARN_LEAD KERN_WARNING LEAD
316 #define INFO_LEAD KERN_INFO LEAD
317 #define NOTE_LEAD KERN_NOTICE LEAD
318 #define ERR_LEAD KERN_ERR LEAD
319 #define DEBUG_LEAD KERN_DEBUG LEAD
320 #define CMDINFO(cmd) \
321 (cmd) ? ((cmd)->device->host->host_no) : -1, \
322 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
323 (cmd) ? ((cmd)->device->lun & 0x07) : -1
325 #define DELAY_DEFAULT 1000
333 #define IRQ_MAX (NR_IRQS-1)
340 not_issued = 0x0001, /* command not yet issued */
341 selecting = 0x0002, /* target is beeing selected */
342 identified = 0x0004, /* IDENTIFY was sent */
343 disconnected = 0x0008, /* target disconnected */
344 completed = 0x0010, /* target sent COMMAND COMPLETE */
345 aborted = 0x0020, /* ABORT was sent */
346 resetted = 0x0040, /* BUS DEVICE RESET was sent */
347 spiordy = 0x0080, /* waiting for SPIORDY to raise */
348 syncneg = 0x0100, /* synchronous negotiation in progress */
349 aborting = 0x0200, /* ABORT is pending */
350 resetting = 0x0400, /* BUS DEVICE RESET is pending */
351 check_condition = 0x0800, /* requesting sense after CHECK CONDITION */
354 MODULE_AUTHOR("Jürgen Fischer");
355 MODULE_DESCRIPTION(AHA152X_REVID);
356 MODULE_LICENSE("GPL");
360 static int io[] = {0, 0};
361 module_param_array(io, int, NULL, 0);
362 MODULE_PARM_DESC(io,"base io address of controller");
364 static int irq[] = {0, 0};
365 module_param_array(irq, int, NULL, 0);
366 MODULE_PARM_DESC(irq,"interrupt for controller");
368 static int scsiid[] = {7, 7};
369 module_param_array(scsiid, int, NULL, 0);
370 MODULE_PARM_DESC(scsiid,"scsi id of controller");
372 static int reconnect[] = {1, 1};
373 module_param_array(reconnect, int, NULL, 0);
374 MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
376 static int parity[] = {1, 1};
377 module_param_array(parity, int, NULL, 0);
378 MODULE_PARM_DESC(parity,"use scsi parity");
380 static int sync[] = {1, 1};
381 module_param_array(sync, int, NULL, 0);
382 MODULE_PARM_DESC(sync,"use synchronous transfers");
384 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
385 module_param_array(delay, int, NULL, 0);
386 MODULE_PARM_DESC(delay,"scsi reset delay");
388 static int exttrans[] = {0, 0};
389 module_param_array(exttrans, int, NULL, 0);
390 MODULE_PARM_DESC(exttrans,"use extended translation");
392 #if !defined(AHA152X_DEBUG)
393 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
394 module_param_array(aha152x, int, NULL, 0);
395 MODULE_PARM_DESC(aha152x, "parameters for first controller");
397 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
398 module_param_array(aha152x1, int, NULL, 0);
399 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
401 static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
402 module_param_array(debug, int, NULL, 0);
403 MODULE_PARM_DESC(debug, "flags for driver debugging");
405 static int aha152x[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
406 module_param_array(aha152x, int, NULL, 0);
407 MODULE_PARM_DESC(aha152x, "parameters for first controller");
409 static int aha152x1[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
410 module_param_array(aha152x1, int, NULL, 0);
411 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
412 #endif /* !defined(AHA152X_DEBUG) */
416 static struct isapnp_device_id id_table[] __devinitdata = {
417 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
418 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1505), 0 },
419 { ISAPNP_ANY_ID, ISAPNP_ANY_ID,
420 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1530), 0 },
421 { ISAPNP_DEVICE_SINGLE_END, }
423 MODULE_DEVICE_TABLE(isapnp, id_table);
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;
544 struct list_head host_list;
549 * host specific command extension
552 struct aha152x_scdata {
553 Scsi_Cmnd *next; /* next sc in queue */
554 struct completion *done;/* semaphore to block on */
555 unsigned char aha_orig_cmd_len;
556 unsigned char aha_orig_cmnd[MAX_COMMAND_SIZE];
560 /* access macros for hostdata */
562 #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
564 #define HOSTNO ((shpnt)->host_no)
566 #define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
567 #define DONE_SC (HOSTDATA(shpnt)->done_SC)
568 #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
569 #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
570 #define QLOCK (HOSTDATA(shpnt)->lock)
571 #define QLOCKER (HOSTDATA(shpnt)->locker)
572 #define QLOCKERL (HOSTDATA(shpnt)->lockerl)
574 #define STATE (HOSTDATA(shpnt)->state)
575 #define PREVSTATE (HOSTDATA(shpnt)->prevstate)
576 #define LASTSTATE (HOSTDATA(shpnt)->laststate)
578 #define RECONN_TARGET (HOSTDATA(shpnt)->target)
580 #define CMD_I (HOSTDATA(shpnt)->cmd_i)
582 #define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
583 #define MSGO_I (HOSTDATA(shpnt)->msgo_i)
584 #define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
585 #define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
587 #define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
588 #define MSGILEN (HOSTDATA(shpnt)->msgi_len)
589 #define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
591 #define DATA_LEN (HOSTDATA(shpnt)->data_len)
593 #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
594 #define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
596 #define DELAY (HOSTDATA(shpnt)->delay)
597 #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
598 #define TC1550 (HOSTDATA(shpnt)->tc1550)
599 #define RECONNECT (HOSTDATA(shpnt)->reconnect)
600 #define PARITY (HOSTDATA(shpnt)->parity)
601 #define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
603 #define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
604 #define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
606 #define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
607 #define SCNEXT(SCpnt) SCDATA(SCpnt)->next
608 #define SCSEM(SCpnt) SCDATA(SCpnt)->done
610 #define SG_ADDRESS(buffer) ((char *) (page_address((buffer)->page)+(buffer)->offset))
613 static void seldi_run(struct Scsi_Host *shpnt);
614 static void seldo_run(struct Scsi_Host *shpnt);
615 static void selto_run(struct Scsi_Host *shpnt);
616 static void busfree_run(struct Scsi_Host *shpnt);
618 static void msgo_init(struct Scsi_Host *shpnt);
619 static void msgo_run(struct Scsi_Host *shpnt);
620 static void msgo_end(struct Scsi_Host *shpnt);
622 static void cmd_init(struct Scsi_Host *shpnt);
623 static void cmd_run(struct Scsi_Host *shpnt);
624 static void cmd_end(struct Scsi_Host *shpnt);
626 static void datai_init(struct Scsi_Host *shpnt);
627 static void datai_run(struct Scsi_Host *shpnt);
628 static void datai_end(struct Scsi_Host *shpnt);
630 static void datao_init(struct Scsi_Host *shpnt);
631 static void datao_run(struct Scsi_Host *shpnt);
632 static void datao_end(struct Scsi_Host *shpnt);
634 static void status_run(struct Scsi_Host *shpnt);
636 static void msgi_run(struct Scsi_Host *shpnt);
637 static void msgi_end(struct Scsi_Host *shpnt);
639 static void parerr_run(struct Scsi_Host *shpnt);
640 static void rsti_run(struct Scsi_Host *shpnt);
642 static void is_complete(struct Scsi_Host *shpnt);
650 void (*init)(struct Scsi_Host *);
651 void (*run)(struct Scsi_Host *);
652 void (*end)(struct Scsi_Host *);
655 { "idle", NULL, NULL, NULL, 0},
656 { "unknown", NULL, NULL, NULL, 0},
657 { "seldo", NULL, seldo_run, NULL, 0},
658 { "seldi", NULL, seldi_run, NULL, 0},
659 { "selto", NULL, selto_run, NULL, 0},
660 { "busfree", NULL, busfree_run, NULL, 0},
661 { "msgo", msgo_init, msgo_run, msgo_end, 1},
662 { "cmd", cmd_init, cmd_run, cmd_end, 1},
663 { "msgi", NULL, msgi_run, msgi_end, 1},
664 { "status", NULL, status_run, NULL, 1},
665 { "datai", datai_init, datai_run, datai_end, 0},
666 { "datao", datao_init, datao_run, datao_end, 0},
667 { "parerr", NULL, parerr_run, NULL, 0},
668 { "rsti", NULL, rsti_run, NULL, 0},
671 /* setup & interrupt */
672 static irqreturn_t intr(int irq, void *dev_id);
673 static void reset_ports(struct Scsi_Host *shpnt);
674 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
675 static void done(struct Scsi_Host *shpnt, int error);
678 static void disp_ports(struct Scsi_Host *shpnt);
679 static void show_command(Scsi_Cmnd * ptr);
680 static void show_queues(struct Scsi_Host *shpnt);
681 static void disp_enintr(struct Scsi_Host *shpnt);
688 static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
692 SCNEXT(new_SC) = NULL;
696 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
698 SCNEXT(end) = new_SC;
702 static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
714 static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
716 Scsi_Cmnd *ptr, *prev;
718 for (ptr = *SC, prev = NULL;
719 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
720 prev = ptr, ptr = SCNEXT(ptr))
725 SCNEXT(prev) = SCNEXT(ptr);
735 static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
737 Scsi_Cmnd *ptr, *prev;
739 for (ptr = *SC, prev = NULL;
741 prev = ptr, ptr = SCNEXT(ptr))
746 SCNEXT(prev) = SCNEXT(ptr);
756 static irqreturn_t swintr(int irqno, void *dev_id)
758 struct Scsi_Host *shpnt = dev_id;
760 HOSTDATA(shpnt)->swint++;
762 SETPORT(DMACNTRL0, INTEN);
766 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
768 struct Scsi_Host *shpnt;
770 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
772 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
776 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
777 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
779 /* need to have host registered before triggering any interrupt */
780 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
782 shpnt->io_port = setup->io_port;
783 shpnt->n_io_port = IO_RANGE;
784 shpnt->irq = setup->irq;
786 if (!setup->tc1550) {
787 HOSTIOPORT0 = setup->io_port;
788 HOSTIOPORT1 = setup->io_port;
790 HOSTIOPORT0 = setup->io_port+0x10;
791 HOSTIOPORT1 = setup->io_port-0x10;
794 spin_lock_init(&QLOCK);
795 RECONNECT = setup->reconnect;
796 SYNCHRONOUS = setup->synchronous;
797 PARITY = setup->parity;
798 DELAY = setup->delay;
799 EXT_TRANS = setup->ext_trans;
801 #if defined(AHA152X_DEBUG)
802 HOSTDATA(shpnt)->debug = setup->debug;
805 SETPORT(SCSIID, setup->scsiid << 4);
806 shpnt->this_id = setup->scsiid;
808 if (setup->reconnect)
809 shpnt->can_queue = AHA152X_MAXQUEUE;
812 printk("aha152x: resetting bus...\n");
813 SETPORT(SCSISEQ, SCSIRSTO);
822 "vital data: rev=%x, "
823 "io=0x%03lx (0x%03lx/0x%03lx), "
830 "extended translation=%s\n",
831 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
833 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
836 RECONNECT ? "enabled" : "disabled",
837 PARITY ? "enabled" : "disabled",
838 SYNCHRONOUS ? "enabled" : "disabled",
840 EXT_TRANS ? "enabled" : "disabled");
842 /* not expecting any interrupts */
846 if( request_irq(shpnt->irq, swintr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
847 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
851 HOSTDATA(shpnt)->swint = 0;
853 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
856 SETPORT(DMACNTRL0, SWINT|INTEN);
858 free_irq(shpnt->irq, shpnt);
860 if (!HOSTDATA(shpnt)->swint) {
861 if (TESTHI(DMASTAT, INTSTAT)) {
867 SETPORT(DMACNTRL0, INTEN);
869 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
870 "Please verify.\n", shpnt->host_no, shpnt->irq);
876 /* clear interrupts */
877 SETPORT(SSTAT0, 0x7f);
878 SETPORT(SSTAT1, 0xef);
880 if ( request_irq(shpnt->irq, intr, IRQF_DISABLED|IRQF_SHARED, "aha152x", shpnt) ) {
881 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
885 if( scsi_add_host(shpnt, NULL) ) {
886 free_irq(shpnt->irq, shpnt);
887 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
891 scsi_scan_host(shpnt);
896 list_del(&HOSTDATA(shpnt)->host_list);
897 scsi_host_put(shpnt);
902 void aha152x_release(struct Scsi_Host *shpnt)
908 free_irq(shpnt->irq, shpnt);
912 release_region(shpnt->io_port, IO_RANGE);
916 if (HOSTDATA(shpnt)->pnpdev)
917 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
920 scsi_remove_host(shpnt);
921 list_del(&HOSTDATA(shpnt)->host_list);
922 scsi_host_put(shpnt);
927 * setup controller to generate interrupts depending
928 * on current state (lock has to be acquired)
931 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
934 CURRENT_SC->SCp.phase |= 1 << 16;
936 if(CURRENT_SC->SCp.phase & selecting) {
937 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
938 SETPORT(SSTAT1, SELTO);
939 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
940 SETPORT(SIMODE1, ENSELTIMO);
942 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
943 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
944 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
946 } else if(STATE==seldi) {
947 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
949 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
951 DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
953 DISCONNECTED_SC ? "(reselection)" : "",
954 ISSUE_SC ? "(busfree)" : "");
955 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
956 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
959 if(!HOSTDATA(shpnt)->in_intr)
960 SETBITS(DMACNTRL0, INTEN);
962 return TESTHI(DMASTAT, INTSTAT);
967 * Queue a command and setup interrupts for a free bus.
969 static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
970 int phase, void (*done)(Scsi_Cmnd *))
972 struct Scsi_Host *shpnt = SCpnt->device->host;
975 #if defined(AHA152X_DEBUG)
976 if (HOSTDATA(shpnt)->debug & debug_queue) {
977 printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
978 CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len, SCpnt->use_sg, SCpnt->request_bufflen);
979 __scsi_print_command(SCpnt->cmnd);
983 SCpnt->scsi_done = done;
984 SCpnt->resid = SCpnt->request_bufflen;
985 SCpnt->SCp.phase = not_issued | phase;
986 SCpnt->SCp.Status = 0x1; /* Ilegal status by SCSI standard */
987 SCpnt->SCp.Message = 0;
988 SCpnt->SCp.have_data_in = 0;
989 SCpnt->SCp.sent_command = 0;
991 if(SCpnt->SCp.phase & (resetting|check_condition)) {
992 if(SCpnt->host_scribble==0 || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
993 printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
997 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
998 if(SCpnt->host_scribble==0) {
999 printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1004 SCNEXT(SCpnt) = NULL;
1005 SCSEM(SCpnt) = complete;
1007 /* setup scratch area
1008 SCp.ptr : buffer pointer
1009 SCp.this_residual : buffer length
1010 SCp.buffer : next buffer
1011 SCp.buffers_residual : left buffers in list
1012 SCp.phase : current state of the command */
1014 if (phase & (check_condition|resetting)) {
1015 if (phase & check_condition) {
1016 SCpnt->SCp.ptr = SCpnt->sense_buffer;
1017 SCpnt->SCp.this_residual = sizeof(SCpnt->sense_buffer);
1018 SCpnt->resid = sizeof(SCpnt->sense_buffer);
1020 SCpnt->SCp.ptr = NULL;
1021 SCpnt->SCp.this_residual = 0;
1024 SCpnt->SCp.buffer = NULL;
1025 SCpnt->SCp.buffers_residual = 0;
1027 if (SCpnt->use_sg) {
1028 SCpnt->SCp.buffer = (struct scatterlist *) SCpnt->request_buffer;
1029 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
1030 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
1031 SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1;
1033 SCpnt->SCp.ptr = (char *) SCpnt->request_buffer;
1034 SCpnt->SCp.this_residual = SCpnt->request_bufflen;
1035 SCpnt->SCp.buffer = NULL;
1036 SCpnt->SCp.buffers_residual = 0;
1042 #if defined(AHA152X_STAT)
1043 HOSTDATA(shpnt)->total_commands++;
1046 /* Turn led on, when this is the first command. */
1047 HOSTDATA(shpnt)->commands++;
1048 if (HOSTDATA(shpnt)->commands==1)
1051 append_SC(&ISSUE_SC, SCpnt);
1053 if(!HOSTDATA(shpnt)->in_intr)
1054 setup_expected_interrupts(shpnt);
1065 static int aha152x_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1068 if(*SCpnt->cmnd == REQUEST_SENSE) {
1076 return aha152x_internal_queue(SCpnt, NULL, 0, done);
1084 static void reset_done(Scsi_Cmnd *SCpnt)
1087 struct Scsi_Host *shpnt = SCpnt->host;
1088 DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1091 complete(SCSEM(SCpnt));
1093 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1101 static int aha152x_abort(Scsi_Cmnd *SCpnt)
1103 struct Scsi_Host *shpnt = SCpnt->device->host;
1105 unsigned long flags;
1107 #if defined(AHA152X_DEBUG)
1108 if(HOSTDATA(shpnt)->debug & debug_eh) {
1109 printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1116 ptr=remove_SC(&ISSUE_SC, SCpnt);
1119 DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1121 HOSTDATA(shpnt)->commands--;
1122 if (!HOSTDATA(shpnt)->commands)
1126 kfree(SCpnt->host_scribble);
1127 SCpnt->host_scribble=NULL;
1136 * for current command: queue ABORT for message out and raise ATN
1137 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1141 printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1150 static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1152 struct Scsi_Host *shpnt = SCpnt->device->host;
1153 DECLARE_COMPLETION(done);
1154 int ret, issued, disconnected;
1155 unsigned char old_cmd_len = SCpnt->cmd_len;
1156 unsigned long flags;
1157 unsigned long timeleft;
1159 #if defined(AHA152X_DEBUG)
1160 if(HOSTDATA(shpnt)->debug & debug_eh) {
1161 printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1166 if(CURRENT_SC==SCpnt) {
1167 printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1172 issued = remove_SC(&ISSUE_SC, SCpnt)==0;
1173 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1178 aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1180 timeleft = wait_for_completion_timeout(&done, 100*HZ);
1182 /* remove command from issue queue */
1184 remove_SC(&ISSUE_SC, SCpnt);
1188 SCpnt->cmd_len = old_cmd_len;
1192 if(SCpnt->SCp.phase & resetted) {
1193 HOSTDATA(shpnt)->commands--;
1194 if (!HOSTDATA(shpnt)->commands)
1196 kfree(SCpnt->host_scribble);
1197 SCpnt->host_scribble=NULL;
1203 append_SC(&ISSUE_SC, SCpnt);
1204 } else if(disconnected) {
1205 append_SC(&DISCONNECTED_SC, SCpnt);
1215 static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1226 printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1230 if (!ptr->device->soft_reset) {
1231 DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1232 remove_SC(SCs, ptr);
1233 HOSTDATA(shpnt)->commands--;
1234 kfree(ptr->host_scribble);
1235 ptr->host_scribble=NULL;
1246 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1248 unsigned long flags;
1252 #if defined(AHA152X_DEBUG)
1253 if(HOSTDATA(shpnt)->debug & debug_eh) {
1254 printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1259 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1260 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1262 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1264 SETPORT(SCSISEQ, SCSIRSTO);
1266 SETPORT(SCSISEQ, 0);
1269 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1271 setup_expected_interrupts(shpnt);
1272 if(HOSTDATA(shpnt)->commands==0)
1284 static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1286 return aha152x_bus_reset_host(SCpnt->device->host);
1290 * Restore default values to the AIC-6260 registers and reset the fifos
1293 static void reset_ports(struct Scsi_Host *shpnt)
1295 unsigned long flags;
1297 /* disable interrupts */
1298 SETPORT(DMACNTRL0, RSTFIFO);
1300 SETPORT(SCSISEQ, 0);
1302 SETPORT(SXFRCTL1, 0);
1303 SETPORT(SCSISIG, 0);
1306 /* clear all interrupt conditions */
1307 SETPORT(SSTAT0, 0x7f);
1308 SETPORT(SSTAT1, 0xef);
1310 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1312 SETPORT(DMACNTRL0, 0);
1313 SETPORT(DMACNTRL1, 0);
1315 SETPORT(BRSTCNTRL, 0xf1);
1317 /* clear SCSI fifos and transfer count */
1318 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1319 SETPORT(SXFRCTL0, CH1);
1322 setup_expected_interrupts(shpnt);
1327 * Reset the host (bus and controller)
1330 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1332 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1334 aha152x_bus_reset_host(shpnt);
1336 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1343 * Reset the host (bus and controller)
1346 static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1348 return aha152x_host_reset_host(SCpnt->device->host);
1352 * Return the "logical geometry"
1355 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1356 sector_t capacity, int *info_array)
1358 struct Scsi_Host *shpnt = sdev->host;
1360 /* try default translation */
1363 info_array[2] = (unsigned long)capacity / (64 * 32);
1365 /* for disks >1GB do some guessing */
1366 if (info_array[2] >= 1024) {
1369 /* try to figure out the geometry from the partition table */
1370 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1371 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1374 "aha152x: unable to verify geometry for disk with >1GB.\n"
1375 " using extended translation.\n");
1376 info_array[0] = 255;
1378 info_array[2] = (unsigned long)capacity / (255 * 63);
1381 "aha152x: unable to verify geometry for disk with >1GB.\n"
1382 " Using default translation. Please verify yourself.\n"
1383 " Perhaps you need to enable extended translation in the driver.\n"
1384 " See Documentation/scsi/aha152x.txt for details.\n");
1387 info_array[0] = info[0];
1388 info_array[1] = info[1];
1389 info_array[2] = info[2];
1391 if (info[0] == 255 && !EXT_TRANS) {
1393 "aha152x: current partition table is using extended translation.\n"
1394 " using it also, although it's not explicitly enabled.\n");
1403 * Internal done function
1406 static void done(struct Scsi_Host *shpnt, int error)
1410 printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1412 DONE_SC = CURRENT_SC;
1414 DONE_SC->result = error;
1416 printk(KERN_ERR "aha152x: done() called outside of command\n");
1419 static struct work_struct aha152x_tq;
1422 * Run service completions on the card with interrupts enabled.
1425 static void run(struct work_struct *work)
1427 struct aha152x_hostdata *hd;
1429 list_for_each_entry(hd, &aha152x_host_list, host_list) {
1430 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1440 static irqreturn_t intr(int irqno, void *dev_id)
1442 struct Scsi_Host *shpnt = (struct Scsi_Host *)dev_id;
1443 unsigned long flags;
1444 unsigned char rev, dmacntrl0;
1447 printk(KERN_ERR "aha152x: catched interrupt %d for unknown controller.\n", irqno);
1452 * Read a couple of registers that are known to not be all 1's. If
1453 * we read all 1's (-1), that means that either:
1455 * a. The host adapter chip has gone bad, and we cannot control it,
1457 * b. The host adapter is a PCMCIA card that has been ejected
1459 * In either case, we cannot do anything with the host adapter at
1460 * this point in time. So just ignore the interrupt and return.
1461 * In the latter case, the interrupt might actually be meant for
1462 * someone else sharing this IRQ, and that driver will handle it.
1465 dmacntrl0 = GETPORT(DMACNTRL0);
1466 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1469 if( TESTLO(DMASTAT, INTSTAT) )
1472 /* no more interrupts from the controller, while we're busy.
1473 INTEN is restored by the BH handler */
1474 CLRBITS(DMACNTRL0, INTEN);
1477 if( HOSTDATA(shpnt)->service==0 ) {
1478 HOSTDATA(shpnt)->service=1;
1480 /* Poke the BH handler */
1481 INIT_WORK(&aha152x_tq, run);
1482 schedule_work(&aha152x_tq);
1491 * - handle completition/disconnection/error of current command
1492 * - start selection for next command (if any)
1494 static void busfree_run(struct Scsi_Host *shpnt)
1496 unsigned long flags;
1497 #if defined(AHA152X_STAT)
1501 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1502 SETPORT(SXFRCTL0, CH1);
1504 SETPORT(SSTAT1, CLRBUSFREE);
1507 #if defined(AHA152X_STAT)
1510 CURRENT_SC->SCp.phase &= ~syncneg;
1512 if(CURRENT_SC->SCp.phase & completed) {
1513 /* target sent COMMAND COMPLETE */
1514 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1516 } else if(CURRENT_SC->SCp.phase & aborted) {
1517 DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1518 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1520 } else if(CURRENT_SC->SCp.phase & resetted) {
1521 DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1522 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1524 } else if(CURRENT_SC->SCp.phase & disconnected) {
1525 /* target sent DISCONNECT */
1526 DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1527 CMDINFO(CURRENT_SC),
1529 CURRENT_SC->request_bufflen);
1530 #if defined(AHA152X_STAT)
1531 HOSTDATA(shpnt)->disconnections++;
1533 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1534 CURRENT_SC->SCp.phase |= 1 << 16;
1538 done(shpnt, DID_ERROR << 16);
1540 #if defined(AHA152X_STAT)
1542 HOSTDATA(shpnt)->busfree_without_old_command++;
1549 #if defined(AHA152X_STAT)
1553 if(DONE_SC->SCp.phase & check_condition) {
1554 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1555 struct aha152x_scdata *sc = SCDATA(cmd);
1558 if(HOSTDATA(shpnt)->debug & debug_eh) {
1559 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1560 scsi_print_sense("bh", DONE_SC);
1564 /* restore old command */
1565 memcpy(cmd->cmnd, sc->aha_orig_cmnd, sizeof(cmd->cmnd));
1566 cmd->cmd_len = sc->aha_orig_cmd_len;
1567 cmd->resid = sc->aha_orig_resid;
1569 cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1571 HOSTDATA(shpnt)->commands--;
1572 if (!HOSTDATA(shpnt)->commands)
1573 SETPORT(PORTA, 0); /* turn led off */
1574 } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1575 #if defined(AHA152X_STAT)
1576 HOSTDATA(shpnt)->busfree_with_check_condition++;
1579 DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1582 if(!(DONE_SC->SCp.phase & not_issued)) {
1583 struct aha152x_scdata *sc;
1584 Scsi_Cmnd *ptr = DONE_SC;
1587 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1590 /* save old command */
1592 /* It was allocated in aha152x_internal_queue? */
1594 memcpy(sc->aha_orig_cmnd, ptr->cmnd,
1596 sc->aha_orig_cmd_len = ptr->cmd_len;
1597 sc->aha_orig_resid = ptr->resid;
1599 ptr->cmnd[0] = REQUEST_SENSE;
1603 ptr->cmnd[4] = sizeof(ptr->sense_buffer);
1608 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1612 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1617 if(DONE_SC && DONE_SC->scsi_done) {
1618 #if defined(AHA152X_DEBUG)
1619 int hostno=DONE_SC->device->host->host_no;
1620 int id=DONE_SC->device->id & 0xf;
1621 int lun=DONE_SC->device->lun & 0x7;
1623 Scsi_Cmnd *ptr = DONE_SC;
1626 /* turn led off, when no commands are in the driver */
1627 HOSTDATA(shpnt)->commands--;
1628 if (!HOSTDATA(shpnt)->commands)
1629 SETPORT(PORTA, 0); /* turn led off */
1631 if(ptr->scsi_done != reset_done) {
1632 kfree(ptr->host_scribble);
1633 ptr->host_scribble=NULL;
1637 DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1638 ptr->scsi_done(ptr);
1639 DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1644 #if defined(AHA152X_STAT)
1646 HOSTDATA(shpnt)->busfree_without_done_command++;
1651 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1656 #if defined(AHA152X_STAT)
1659 CURRENT_SC->SCp.phase |= selecting;
1661 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1663 /* clear selection timeout */
1664 SETPORT(SSTAT1, SELTO);
1666 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1667 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1668 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1670 #if defined(AHA152X_STAT)
1671 HOSTDATA(shpnt)->busfree_without_new_command++;
1673 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1676 #if defined(AHA152X_STAT)
1678 HOSTDATA(shpnt)->busfree_without_any_action++;
1683 * Selection done (OUT)
1684 * - queue IDENTIFY message and SDTR to selected target for message out
1685 * (ATN asserted automagically via ENAUTOATNO in busfree())
1687 static void seldo_run(struct Scsi_Host *shpnt)
1689 SETPORT(SCSISIG, 0);
1690 SETPORT(SSTAT1, CLRBUSFREE);
1691 SETPORT(SSTAT1, CLRPHASECHG);
1693 CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1695 SETPORT(SCSISEQ, 0);
1697 if (TESTLO(SSTAT0, SELDO)) {
1698 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1699 done(shpnt, DID_NO_CONNECT << 16);
1703 SETPORT(SSTAT0, CLRSELDO);
1705 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1707 if (CURRENT_SC->SCp.phase & aborting) {
1709 } else if (CURRENT_SC->SCp.phase & resetting) {
1710 ADDMSGO(BUS_DEVICE_RESET);
1711 } else if (SYNCNEG==0 && SYNCHRONOUS) {
1712 CURRENT_SC->SCp.phase |= syncneg;
1713 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1714 SYNCNEG=1; /* negotiation in progress */
1722 * - return command to mid-level with failure cause
1725 static void selto_run(struct Scsi_Host *shpnt)
1727 SETPORT(SCSISEQ, 0);
1728 SETPORT(SSTAT1, CLRSELTIMO);
1730 DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1733 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1737 CURRENT_SC->SCp.phase &= ~selecting;
1739 if (CURRENT_SC->SCp.phase & aborted) {
1740 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1741 done(shpnt, DID_ABORT << 16);
1742 } else if (TESTLO(SSTAT0, SELINGO)) {
1743 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1744 done(shpnt, DID_BUS_BUSY << 16);
1746 /* ARBITRATION won, but SELECTION failed */
1747 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1748 done(shpnt, DID_NO_CONNECT << 16);
1754 * - put current command back to issue queue
1755 * (reconnection of a disconnected nexus instead
1756 * of successful selection out)
1759 static void seldi_run(struct Scsi_Host *shpnt)
1763 unsigned long flags;
1765 SETPORT(SCSISIG, 0);
1766 SETPORT(SSTAT0, CLRSELDI);
1767 SETPORT(SSTAT1, CLRBUSFREE);
1768 SETPORT(SSTAT1, CLRPHASECHG);
1771 if(!(CURRENT_SC->SCp.phase & not_issued))
1772 printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1774 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1777 append_SC(&ISSUE_SC, CURRENT_SC);
1783 if(!DISCONNECTED_SC) {
1784 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1790 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1793 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1797 for(target=7; !(selid & (1 << target)); target--)
1800 if(selid & ~(1 << target)) {
1801 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1806 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1807 SETPORT(SCSISEQ, 0);
1809 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1811 RECONN_TARGET=target;
1812 DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1817 * - handle initial message after reconnection to identify
1818 * reconnecting nexus
1819 * - queue command on DISCONNECTED_SC on DISCONNECT message
1820 * - set completed flag on COMMAND COMPLETE
1821 * (other completition code moved to busfree_run)
1822 * - handle response to SDTR
1823 * - clear synchronous transfer agreements on BUS RESET
1825 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1828 static void msgi_run(struct Scsi_Host *shpnt)
1831 int sstat1 = GETPORT(SSTAT1);
1833 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1836 if(TESTLO(SSTAT0,SPIORDY)) {
1837 DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1841 ADDMSGI(GETPORT(SCSIDAT));
1843 #if defined(AHA152X_DEBUG)
1844 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1845 printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1846 spi_print_msg(&MSGI(0));
1852 if(LASTSTATE!=seldi) {
1853 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1857 * Handle reselection
1859 if(!(MSGI(0) & IDENTIFY_BASE)) {
1860 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1864 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1868 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1872 DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1874 CURRENT_SC->SCp.Message = MSGI(0);
1875 CURRENT_SC->SCp.phase &= ~disconnected;
1879 /* next message if any */
1883 CURRENT_SC->SCp.Message = MSGI(0);
1888 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1890 CURRENT_SC->SCp.phase |= disconnected;
1893 case COMMAND_COMPLETE:
1894 if(CURRENT_SC->SCp.phase & completed)
1895 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1897 CURRENT_SC->SCp.phase |= completed;
1900 case MESSAGE_REJECT:
1902 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1903 SYNCNEG=2; /* negotiation completed */
1905 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1911 case RESTORE_POINTERS:
1914 case EXTENDED_MESSAGE:
1915 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1916 /* not yet completed */
1926 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1930 if (!HOSTDATA(shpnt)->synchronous)
1933 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1934 spi_print_msg(&MSGI(0));
1937 ticks = (MSGI(3) * 4 + 49) / 50;
1940 /* negotiation in progress */
1941 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1942 ADDMSGO(MESSAGE_REJECT);
1943 printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1947 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1948 } else if (ticks <= 9 && MSGI(4) >= 1) {
1949 ADDMSGO(EXTENDED_MESSAGE);
1951 ADDMSGO(EXTENDED_SDTR);
1963 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1965 /* requested SDTR is too slow, do it asynchronously */
1966 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1967 ADDMSGO(MESSAGE_REJECT);
1970 SYNCNEG=2; /* negotiation completed */
1975 case BUS_DEVICE_RESET:
1979 for(i=0; i<8; i++) {
1980 HOSTDATA(shpnt)->syncrate[i]=0;
1981 HOSTDATA(shpnt)->syncneg[i]=0;
1987 case EXTENDED_MODIFY_DATA_POINTER:
1988 case EXTENDED_EXTENDED_IDENTIFY:
1991 ADDMSGO(MESSAGE_REJECT);
2001 static void msgi_end(struct Scsi_Host *shpnt)
2004 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
2006 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
2007 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
2008 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
2016 static void msgo_init(struct Scsi_Host *shpnt)
2019 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2020 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2022 printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2023 ADDMSGO(MESSAGE_REJECT);
2027 #if defined(AHA152X_DEBUG)
2028 if(HOSTDATA(shpnt)->debug & debug_msgo) {
2031 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2032 for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2043 static void msgo_run(struct Scsi_Host *shpnt)
2046 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2048 while(MSGO_I<MSGOLEN) {
2049 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2051 if(TESTLO(SSTAT0, SPIORDY)) {
2052 DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2056 if (MSGO_I==MSGOLEN-1) {
2057 /* Leave MESSAGE OUT after transfer */
2058 SETPORT(SSTAT1, CLRATNO);
2062 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2063 CURRENT_SC->SCp.phase |= identified;
2065 if (MSGO(MSGO_I)==ABORT)
2066 CURRENT_SC->SCp.phase |= aborted;
2068 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2069 CURRENT_SC->SCp.phase |= resetted;
2071 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2075 static void msgo_end(struct Scsi_Host *shpnt)
2077 if(MSGO_I<MSGOLEN) {
2078 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2080 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2093 static void cmd_init(struct Scsi_Host *shpnt)
2095 if (CURRENT_SC->SCp.sent_command) {
2096 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2097 done(shpnt, DID_ERROR << 16);
2101 #if defined(AHA152X_DEBUG)
2102 if (HOSTDATA(shpnt)->debug & debug_cmd) {
2103 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2104 __scsi_print_command(CURRENT_SC->cmnd);
2115 static void cmd_run(struct Scsi_Host *shpnt)
2117 if(CMD_I==CURRENT_SC->cmd_len) {
2118 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2122 while(CMD_I<CURRENT_SC->cmd_len) {
2123 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);
2125 if(TESTLO(SSTAT0, SPIORDY)) {
2126 DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2130 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2134 static void cmd_end(struct Scsi_Host *shpnt)
2136 if(CMD_I<CURRENT_SC->cmd_len)
2137 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2139 CURRENT_SC->SCp.sent_command++;
2146 static void status_run(struct Scsi_Host *shpnt)
2148 if(TESTLO(SSTAT0,SPIORDY)) {
2149 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2153 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2155 #if defined(AHA152X_DEBUG)
2156 if (HOSTDATA(shpnt)->debug & debug_status) {
2157 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2158 scsi_print_status(CURRENT_SC->SCp.Status);
2168 static void datai_init(struct Scsi_Host *shpnt)
2170 SETPORT(DMACNTRL0, RSTFIFO);
2171 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2173 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2174 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2176 SETPORT(SIMODE0, 0);
2177 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2180 DPRINTK(debug_datai,
2181 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2182 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2185 static void datai_run(struct Scsi_Host *shpnt)
2187 unsigned long the_time;
2188 int fifodata, data_count;
2191 * loop while the phase persists or the fifos are not empty
2194 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2195 /* FIXME: maybe this should be done by setting up
2196 * STCNT to trigger ENSWRAP interrupt, instead of
2197 * polling for DFIFOFULL
2199 the_time=jiffies + 100*HZ;
2200 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2203 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2204 printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2209 if(TESTHI(DMASTAT, DFIFOFULL)) {
2212 the_time=jiffies + 100*HZ;
2213 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2216 if(TESTLO(SSTAT2, SEMPTY)) {
2217 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2222 fifodata = GETPORT(FIFOSTAT);
2225 if(CURRENT_SC->SCp.this_residual>0) {
2226 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2227 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2228 CURRENT_SC->SCp.this_residual :
2230 fifodata -= data_count;
2232 if(data_count & 1) {
2233 DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2234 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2235 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2236 CURRENT_SC->SCp.this_residual--;
2238 SETPORT(DMACNTRL0, ENDMA);
2241 if(data_count > 1) {
2242 DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2244 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2245 CURRENT_SC->SCp.ptr += 2 * data_count;
2246 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2247 DATA_LEN += 2 * data_count;
2250 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2251 /* advance to next buffer */
2252 CURRENT_SC->SCp.buffers_residual--;
2253 CURRENT_SC->SCp.buffer++;
2254 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2255 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2258 } else if(fifodata>0) {
2259 printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2260 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2263 data=GETPORT(DATAPORT);
2264 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2268 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2272 if(TESTLO(DMASTAT, INTSTAT) ||
2273 TESTLO(DMASTAT, DFIFOEMP) ||
2274 TESTLO(SSTAT2, SEMPTY) ||
2275 GETPORT(FIFOSTAT)>0) {
2277 * something went wrong, if there's something left in the fifos
2278 * or the phase didn't change
2280 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2284 if(DATA_LEN!=GETSTCNT()) {
2286 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2287 CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2293 static void datai_end(struct Scsi_Host *shpnt)
2295 CURRENT_SC->resid -= GETSTCNT();
2297 DPRINTK(debug_datai,
2298 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2299 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid, GETSTCNT());
2301 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2302 SETPORT(DMACNTRL0, 0);
2309 static void datao_init(struct Scsi_Host *shpnt)
2311 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2312 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2314 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2315 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2317 SETPORT(SIMODE0, 0);
2318 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2320 DATA_LEN = CURRENT_SC->resid;
2322 DPRINTK(debug_datao,
2323 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2324 CMDINFO(CURRENT_SC), CURRENT_SC->request_bufflen, CURRENT_SC->resid);
2327 static void datao_run(struct Scsi_Host *shpnt)
2329 unsigned long the_time;
2332 /* until phase changes or all data sent */
2333 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2335 if(data_count > CURRENT_SC->SCp.this_residual)
2336 data_count=CURRENT_SC->SCp.this_residual;
2338 if(TESTLO(DMASTAT, DFIFOEMP)) {
2339 printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2344 if(data_count & 1) {
2345 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2346 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2347 CURRENT_SC->SCp.this_residual--;
2348 CURRENT_SC->resid--;
2349 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2352 if(data_count > 1) {
2354 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2355 CURRENT_SC->SCp.ptr += 2 * data_count;
2356 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2357 CURRENT_SC->resid -= 2 * data_count;
2360 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2361 /* advance to next buffer */
2362 CURRENT_SC->SCp.buffers_residual--;
2363 CURRENT_SC->SCp.buffer++;
2364 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2365 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2368 the_time=jiffies + 100*HZ;
2369 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2372 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2373 printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2380 static void datao_end(struct Scsi_Host *shpnt)
2382 if(TESTLO(DMASTAT, DFIFOEMP)) {
2383 int data_count = (DATA_LEN - CURRENT_SC->resid) - GETSTCNT();
2385 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2386 CMDINFO(CURRENT_SC),
2388 DATA_LEN-CURRENT_SC->resid,
2391 CURRENT_SC->resid += data_count;
2393 if(CURRENT_SC->use_sg) {
2394 data_count -= CURRENT_SC->SCp.ptr - SG_ADDRESS(CURRENT_SC->SCp.buffer);
2395 while(data_count>0) {
2396 CURRENT_SC->SCp.buffer--;
2397 CURRENT_SC->SCp.buffers_residual++;
2398 data_count -= CURRENT_SC->SCp.buffer->length;
2400 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) - data_count;
2401 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length + data_count;
2403 CURRENT_SC->SCp.ptr -= data_count;
2404 CURRENT_SC->SCp.this_residual += data_count;
2408 DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2409 CMDINFO(CURRENT_SC),
2410 CURRENT_SC->request_bufflen,
2414 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2415 SETPORT(SXFRCTL0, CH1);
2417 SETPORT(DMACNTRL0, 0);
2421 * figure out what state we're in
2424 static int update_state(struct Scsi_Host *shpnt)
2427 unsigned int stat0 = GETPORT(SSTAT0);
2428 unsigned int stat1 = GETPORT(SSTAT1);
2433 if(stat1 & SCSIRSTI) {
2436 SETPORT(SSTAT1,SCSIRSTI);
2437 } else if(stat0 & SELDI && PREVSTATE==busfree) {
2439 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2441 } else if(stat1 & SELTO) {
2443 } else if(stat1 & BUSFREE) {
2445 SETPORT(SSTAT1,BUSFREE);
2446 } else if(stat1 & SCSIPERR) {
2448 SETPORT(SSTAT1,SCSIPERR);
2449 } else if(stat1 & REQINIT) {
2450 switch(GETPORT(SCSISIG) & P_MASK) {
2451 case P_MSGI: STATE=msgi; break;
2452 case P_MSGO: STATE=msgo; break;
2453 case P_DATAO: STATE=datao; break;
2454 case P_DATAI: STATE=datai; break;
2455 case P_STATUS: STATE=status; break;
2456 case P_CMD: STATE=cmd; break;
2461 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2462 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2466 if(STATE!=PREVSTATE) {
2467 LASTSTATE=PREVSTATE;
2474 * handle parity error
2476 * FIXME: in which phase?
2479 static void parerr_run(struct Scsi_Host *shpnt)
2481 printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2482 done(shpnt, DID_PARITY << 16);
2489 static void rsti_run(struct Scsi_Host *shpnt)
2493 printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2495 ptr=DISCONNECTED_SC;
2497 Scsi_Cmnd *next = SCNEXT(ptr);
2499 if (!ptr->device->soft_reset) {
2500 remove_SC(&DISCONNECTED_SC, ptr);
2502 kfree(ptr->host_scribble);
2503 ptr->host_scribble=NULL;
2505 ptr->result = DID_RESET << 16;
2506 ptr->scsi_done(ptr);
2512 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2513 done(shpnt, DID_RESET << 16 );
2518 * bottom-half handler
2521 static void is_complete(struct Scsi_Host *shpnt)
2524 unsigned long flags;
2532 if( HOSTDATA(shpnt)->service==0 ) {
2537 HOSTDATA(shpnt)->service = 0;
2539 if(HOSTDATA(shpnt)->in_intr) {
2541 /* aha152x_error never returns.. */
2542 aha152x_error(shpnt, "bottom-half already running!?");
2544 HOSTDATA(shpnt)->in_intr++;
2547 * loop while there are interrupt conditions pending
2551 unsigned long start = jiffies;
2554 dataphase=update_state(shpnt);
2556 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2559 * end previous state
2562 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2563 states[PREVSTATE].end(shpnt);
2566 * disable SPIO mode if previous phase used it
2567 * and this one doesn't
2570 if(states[PREVSTATE].spio && !states[STATE].spio) {
2571 SETPORT(SXFRCTL0, CH1);
2572 SETPORT(DMACNTRL0, 0);
2574 CURRENT_SC->SCp.phase &= ~spiordy;
2578 * accept current dataphase phase
2582 SETPORT(SSTAT0, REQINIT);
2583 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2584 SETPORT(SSTAT1, PHASECHG);
2588 * enable SPIO mode if previous didn't use it
2592 if(!states[PREVSTATE].spio && states[STATE].spio) {
2593 SETPORT(DMACNTRL0, 0);
2594 SETPORT(SXFRCTL0, CH1|SPIOEN);
2596 CURRENT_SC->SCp.phase |= spiordy;
2600 * initialize for new state
2603 if(PREVSTATE!=STATE && states[STATE].init)
2604 states[STATE].init(shpnt);
2607 * handle current state
2610 if(states[STATE].run)
2611 states[STATE].run(shpnt);
2613 printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2616 * setup controller to interrupt on
2617 * the next expected condition and
2618 * loop if it's already there
2622 pending=setup_expected_interrupts(shpnt);
2623 #if defined(AHA152X_STAT)
2624 HOSTDATA(shpnt)->count[STATE]++;
2625 if(PREVSTATE!=STATE)
2626 HOSTDATA(shpnt)->count_trans[STATE]++;
2627 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2630 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2634 * enable interrupts and leave bottom-half
2637 HOSTDATA(shpnt)->in_intr--;
2638 SETBITS(DMACNTRL0, INTEN);
2644 * Dump the current driver status and panic
2646 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2648 printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2650 panic("aha152x panic\n");
2654 * Display registers of AIC-6260
2656 static void disp_ports(struct Scsi_Host *shpnt)
2658 #if defined(AHA152X_DEBUG)
2661 printk("\n%s: %s(%s) ",
2662 CURRENT_SC ? "busy" : "waiting",
2664 states[PREVSTATE].name);
2666 s = GETPORT(SCSISEQ);
2667 printk("SCSISEQ( ");
2669 printk("TARGET MODE ");
2677 printk("AUTOATNO ");
2679 printk("AUTOATNI ");
2681 printk("AUTOATNP ");
2683 printk("SCSIRSTO ");
2686 printk(" SCSISIG(");
2687 s = GETPORT(SCSISIG);
2688 switch (s & P_MASK) {
2702 printk("MESSAGE OUT");
2705 printk("MESSAGE IN");
2708 printk("*invalid*");
2714 printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2717 s = GETPORT(SSTAT0);
2735 s = GETPORT(SSTAT1);
2741 printk("SCSIRSTI ");
2743 printk("PHASEMIS ");
2747 printk("SCSIPERR ");
2749 printk("PHASECHG ");
2757 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2776 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2783 printk("SCSIRSTI ");
2785 printk("PHASEMIS ");
2789 printk("SCSIPERR ");
2791 printk("PHASECHG ");
2796 printk("SXFRCTL0( ");
2798 s = GETPORT(SXFRCTL0);
2806 printk("CLRSTCNT ");
2815 s = GETPORT(SCSISIG);
2828 printk("SELID (%02x), ", GETPORT(SELID));
2830 printk("STCNT (%d), ", GETSTCNT());
2834 s = GETPORT(SSTAT2);
2841 printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2843 s = GETPORT(SSTAT3);
2844 printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2847 s = GETPORT(SSTAT4);
2856 printk("DMACNTRL0( ");
2857 s = GETPORT(DMACNTRL0);
2858 printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2859 printk("%s ", s & DMA ? "DMA" : "PIO");
2860 printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2871 printk("DMASTAT( ");
2872 s = GETPORT(DMASTAT);
2878 printk("DFIFOFULL ");
2880 printk("DFIFOEMP ");
2886 * display enabled interrupts
2888 static void disp_enintr(struct Scsi_Host *shpnt)
2892 printk(KERN_DEBUG "enabled interrupts ( ");
2894 s = GETPORT(SIMODE0);
2900 printk("ENSELINGO ");
2906 printk("ENSPIORDY ");
2908 printk("ENDMADONE ");
2910 s = GETPORT(SIMODE1);
2912 printk("ENSELTIMO ");
2914 printk("ENATNTARG ");
2916 printk("ENPHASEMIS ");
2918 printk("ENBUSFREE ");
2920 printk("ENSCSIPERR ");
2922 printk("ENPHASECHG ");
2924 printk("ENREQINIT ");
2929 * Show the command data of a command
2931 static void show_command(Scsi_Cmnd *ptr)
2933 scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2935 __scsi_print_command(ptr->cmnd);
2937 printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2938 ptr->request_bufflen, ptr->resid);
2940 if (ptr->SCp.phase & not_issued)
2941 printk("not issued|");
2942 if (ptr->SCp.phase & selecting)
2943 printk("selecting|");
2944 if (ptr->SCp.phase & identified)
2945 printk("identified|");
2946 if (ptr->SCp.phase & disconnected)
2947 printk("disconnected|");
2948 if (ptr->SCp.phase & completed)
2949 printk("completed|");
2950 if (ptr->SCp.phase & spiordy)
2952 if (ptr->SCp.phase & syncneg)
2954 if (ptr->SCp.phase & aborted)
2956 if (ptr->SCp.phase & resetted)
2957 printk("resetted|");
2959 printk("; next=0x%p\n", SCNEXT(ptr));
2961 printk("; next=(host scribble NULL)\n");
2966 * Dump the queued data
2968 static void show_queues(struct Scsi_Host *shpnt)
2971 unsigned long flags;
2974 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2975 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2979 printk(KERN_DEBUG "current_SC:\n");
2981 show_command(CURRENT_SC);
2983 printk(KERN_DEBUG "none\n");
2985 printk(KERN_DEBUG "disconnected_SC:\n");
2986 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2994 #define SPRINTF(args...) pos += sprintf(pos, ## args)
2996 static int get_command(char *pos, Scsi_Cmnd * ptr)
3001 SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
3002 (unsigned int) ptr, ptr->device->id, ptr->device->lun);
3004 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
3005 SPRINTF("0x%02x ", ptr->cmnd[i]);
3007 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
3008 ptr->resid, ptr->SCp.this_residual, ptr->SCp.buffers_residual);
3010 if (ptr->SCp.phase & not_issued)
3011 SPRINTF("not issued|");
3012 if (ptr->SCp.phase & selecting)
3013 SPRINTF("selecting|");
3014 if (ptr->SCp.phase & disconnected)
3015 SPRINTF("disconnected|");
3016 if (ptr->SCp.phase & aborted)
3017 SPRINTF("aborted|");
3018 if (ptr->SCp.phase & identified)
3019 SPRINTF("identified|");
3020 if (ptr->SCp.phase & completed)
3021 SPRINTF("completed|");
3022 if (ptr->SCp.phase & spiordy)
3023 SPRINTF("spiordy|");
3024 if (ptr->SCp.phase & syncneg)
3025 SPRINTF("syncneg|");
3026 SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3028 return (pos - start);
3031 static int get_ports(struct Scsi_Host *shpnt, char *pos)
3036 SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3038 s = GETPORT(SCSISEQ);
3039 SPRINTF("SCSISEQ( ");
3041 SPRINTF("TARGET MODE ");
3049 SPRINTF("AUTOATNO ");
3051 SPRINTF("AUTOATNI ");
3053 SPRINTF("AUTOATNP ");
3055 SPRINTF("SCSIRSTO ");
3058 SPRINTF(" SCSISIG(");
3059 s = GETPORT(SCSISIG);
3060 switch (s & P_MASK) {
3062 SPRINTF("DATA OUT");
3074 SPRINTF("MESSAGE OUT");
3077 SPRINTF("MESSAGE IN");
3080 SPRINTF("*invalid*");
3086 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3089 s = GETPORT(SSTAT0);
3097 SPRINTF("SELINGO ");
3103 SPRINTF("SPIORDY ");
3105 SPRINTF("DMADONE ");
3107 s = GETPORT(SSTAT1);
3111 SPRINTF("ATNTARG ");
3113 SPRINTF("SCSIRSTI ");
3115 SPRINTF("PHASEMIS ");
3117 SPRINTF("BUSFREE ");
3119 SPRINTF("SCSIPERR ");
3121 SPRINTF("PHASECHG ");
3123 SPRINTF("REQINIT ");
3129 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3138 SPRINTF("SELINGO ");
3144 SPRINTF("SPIORDY ");
3146 SPRINTF("DMADONE ");
3148 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3153 SPRINTF("ATNTARG ");
3155 SPRINTF("SCSIRSTI ");
3157 SPRINTF("PHASEMIS ");
3159 SPRINTF("BUSFREE ");
3161 SPRINTF("SCSIPERR ");
3163 SPRINTF("PHASECHG ");
3165 SPRINTF("REQINIT ");
3168 SPRINTF("SXFRCTL0( ");
3170 s = GETPORT(SXFRCTL0);
3178 SPRINTF("CLRSTCNT ");
3185 SPRINTF("SIGNAL( ");
3187 s = GETPORT(SCSISIG);
3200 SPRINTF("SELID(%02x), ", GETPORT(SELID));
3202 SPRINTF("STCNT(%d), ", GETSTCNT());
3204 SPRINTF("SSTAT2( ");
3206 s = GETPORT(SSTAT2);
3208 SPRINTF("SOFFSET ");
3213 SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3215 s = GETPORT(SSTAT3);
3216 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3218 SPRINTF("SSTAT4( ");
3219 s = GETPORT(SSTAT4);
3221 SPRINTF("SYNCERR ");
3228 SPRINTF("DMACNTRL0( ");
3229 s = GETPORT(DMACNTRL0);
3230 SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3231 SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3232 SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3238 SPRINTF("RSTFIFO ");
3243 SPRINTF("DMASTAT( ");
3244 s = GETPORT(DMASTAT);
3248 SPRINTF("WORDRDY ");
3250 SPRINTF("DFIFOFULL ");
3252 SPRINTF("DFIFOEMP ");
3255 SPRINTF("enabled interrupts( ");
3257 s = GETPORT(SIMODE0);
3259 SPRINTF("ENSELDO ");
3261 SPRINTF("ENSELDI ");
3263 SPRINTF("ENSELINGO ");
3265 SPRINTF("ENSWRAP ");
3267 SPRINTF("ENSDONE ");
3269 SPRINTF("ENSPIORDY ");
3271 SPRINTF("ENDMADONE ");
3273 s = GETPORT(SIMODE1);
3275 SPRINTF("ENSELTIMO ");
3277 SPRINTF("ENATNTARG ");
3279 SPRINTF("ENPHASEMIS ");
3281 SPRINTF("ENBUSFREE ");
3283 SPRINTF("ENSCSIPERR ");
3285 SPRINTF("ENPHASECHG ");
3287 SPRINTF("ENREQINIT ");
3290 return (pos - start);
3293 static int aha152x_set_info(char *buffer, int length, struct Scsi_Host *shpnt)
3295 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3298 #if defined(AHA152X_DEBUG)
3299 if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3300 int debug = HOSTDATA(shpnt)->debug;
3302 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3304 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3307 #if defined(AHA152X_STAT)
3308 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3311 HOSTDATA(shpnt)->total_commands=0;
3312 HOSTDATA(shpnt)->disconnections=0;
3313 HOSTDATA(shpnt)->busfree_without_any_action=0;
3314 HOSTDATA(shpnt)->busfree_without_old_command=0;
3315 HOSTDATA(shpnt)->busfree_without_new_command=0;
3316 HOSTDATA(shpnt)->busfree_without_done_command=0;
3317 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3318 for (i = idle; i<maxstate; i++) {
3319 HOSTDATA(shpnt)->count[i]=0;
3320 HOSTDATA(shpnt)->count_trans[i]=0;
3321 HOSTDATA(shpnt)->time[i]=0;
3324 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3337 #define SPRINTF(args...) \
3338 do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3340 static int aha152x_proc_info(struct Scsi_Host *shpnt, char *buffer, char **start,
3341 off_t offset, int length, int inout)
3346 unsigned long flags;
3349 DPRINTK(debug_procinfo,
3350 KERN_DEBUG "aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3351 buffer, offset, length, shpnt->host_no, inout);
3355 return aha152x_set_info(buffer, length, shpnt);
3357 SPRINTF(AHA152X_REVID "\n");
3359 SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3360 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3361 SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3362 SPRINTF("disconnection/reconnection %s\n",
3363 RECONNECT ? "enabled" : "disabled");
3364 SPRINTF("parity checking %s\n",
3365 PARITY ? "enabled" : "disabled");
3366 SPRINTF("synchronous transfers %s\n",
3367 SYNCHRONOUS ? "enabled" : "disabled");
3368 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3371 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3372 for (i = 0; i < 8; i++)
3373 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3374 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3376 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3377 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3378 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3380 #if defined(AHA152X_DEBUG)
3381 #define PDEBUG(flags,txt) \
3382 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3384 SPRINTF("enabled debugging options: ");
3386 PDEBUG(debug_procinfo, "procinfo");
3387 PDEBUG(debug_queue, "queue");
3388 PDEBUG(debug_intr, "interrupt");
3389 PDEBUG(debug_selection, "selection");
3390 PDEBUG(debug_msgo, "message out");
3391 PDEBUG(debug_msgi, "message in");
3392 PDEBUG(debug_status, "status");
3393 PDEBUG(debug_cmd, "command");
3394 PDEBUG(debug_datai, "data in");
3395 PDEBUG(debug_datao, "data out");
3396 PDEBUG(debug_eh, "eh");
3397 PDEBUG(debug_locking, "locks");
3398 PDEBUG(debug_phases, "phases");
3403 SPRINTF("\nqueue status:\n");
3406 SPRINTF("not yet issued commands:\n");
3407 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3408 pos += get_command(pos, ptr);
3410 SPRINTF("no not yet issued commands\n");
3414 SPRINTF("current command:\n");
3415 pos += get_command(pos, CURRENT_SC);
3417 SPRINTF("no current command\n");
3419 if (DISCONNECTED_SC) {
3420 SPRINTF("disconnected commands:\n");
3421 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3422 pos += get_command(pos, ptr);
3424 SPRINTF("no disconnected commands\n");
3426 pos += get_ports(shpnt, pos);
3428 #if defined(AHA152X_STAT)
3429 SPRINTF("statistics:\n"
3430 "total commands: %d\n"
3431 "disconnections: %d\n"
3432 "busfree with check condition: %d\n"
3433 "busfree without old command: %d\n"
3434 "busfree without new command: %d\n"
3435 "busfree without done command: %d\n"
3436 "busfree without any action: %d\n"
3441 HOSTDATA(shpnt)->total_commands,
3442 HOSTDATA(shpnt)->disconnections,
3443 HOSTDATA(shpnt)->busfree_with_check_condition,
3444 HOSTDATA(shpnt)->busfree_without_old_command,
3445 HOSTDATA(shpnt)->busfree_without_new_command,
3446 HOSTDATA(shpnt)->busfree_without_done_command,
3447 HOSTDATA(shpnt)->busfree_without_any_action);
3448 for(i=0; i<maxstate; i++) {
3449 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3451 HOSTDATA(shpnt)->count_trans[i],
3452 HOSTDATA(shpnt)->count[i],
3453 HOSTDATA(shpnt)->time[i]);
3457 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: pos=%p\n", pos);
3459 thislength = pos - (buffer + offset);
3460 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: length=%d thislength=%d\n", length, thislength);
3463 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: output too short\n");
3468 thislength = thislength<length ? thislength : length;
3470 DPRINTK(debug_procinfo, KERN_DEBUG "aha152x_proc_info: return %d\n", thislength);
3472 *start = buffer + offset;
3473 return thislength < length ? thislength : length;
3476 static int aha152x_adjust_queue(struct scsi_device *device)
3478 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
3482 static struct scsi_host_template aha152x_driver_template = {
3483 .module = THIS_MODULE,
3484 .name = AHA152X_REVID,
3485 .proc_name = "aha152x",
3486 .proc_info = aha152x_proc_info,
3487 .queuecommand = aha152x_queue,
3488 .eh_abort_handler = aha152x_abort,
3489 .eh_device_reset_handler = aha152x_device_reset,
3490 .eh_bus_reset_handler = aha152x_bus_reset,
3491 .eh_host_reset_handler = aha152x_host_reset,
3492 .bios_param = aha152x_biosparam,
3495 .sg_tablesize = SG_ALL,
3497 .use_clustering = DISABLE_CLUSTERING,
3498 .slave_alloc = aha152x_adjust_queue,
3501 #if !defined(PCMCIA)
3502 static int setup_count;
3503 static struct aha152x_setup setup[2];
3505 /* possible i/o addresses for the AIC-6260; default first */
3506 static unsigned short ports[] = { 0x340, 0x140 };
3508 #if !defined(SKIP_BIOSTEST)
3509 /* possible locations for the Adaptec BIOS; defaults first */
3510 static unsigned int addresses[] =
3512 0xdc000, /* default first */
3519 0xeb800, /* VTech Platinum SMP */
3523 /* signatures for various AIC-6[23]60 based controllers.
3524 The point in detecting signatures is to avoid useless and maybe
3525 harmful probes on ports. I'm not sure that all listed boards pass
3526 auto-configuration. For those which fail the BIOS signature is
3527 obsolete, because user intervention to supply the configuration is
3528 needed anyway. May be an information whether or not the BIOS supports
3529 extended translation could be also useful here. */
3530 static struct signature {
3531 unsigned char *signature;
3536 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3538 { "Adaptec AHA-1520B", 0x000b, 17 },
3539 /* Adaptec 152x rev B */
3540 { "Adaptec AHA-1520B", 0x0026, 17 },
3541 /* Iomega Jaz Jet ISA (AIC6370Q) */
3542 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3543 /* on-board controller */
3544 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3545 /* on-board controller */
3546 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3547 /* on-board controller */
3548 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3549 /* on-board controller */
3550 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3551 /* ScsiPro-Controller */
3552 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3553 /* Gigabyte Local-Bus-SCSI */
3554 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3556 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3557 /* IBM Thinkpad Dock II */
3558 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3559 /* IBM Thinkpad Dock II SCSI */
3560 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3561 /* DTC 3520A ISA SCSI */
3563 #endif /* !SKIP_BIOSTEST */
3566 * Test, if port_base is valid.
3569 static int aha152x_porttest(int io_port)
3573 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3574 for (i = 0; i < 16; i++)
3575 SETPORT(io_port + O_STACK, i);
3577 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3578 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3584 static int tc1550_porttest(int io_port)
3588 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3589 for (i = 0; i < 16; i++)
3590 SETPORT(io_port + O_STACK, i);
3592 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3593 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3600 static int checksetup(struct aha152x_setup *setup)
3603 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3606 if (i == ARRAY_SIZE(ports))
3609 if ( request_region(setup->io_port, IO_RANGE, "aha152x")==0 ) {
3610 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3614 if( aha152x_porttest(setup->io_port) ) {
3616 } else if( tc1550_porttest(setup->io_port) ) {
3619 release_region(setup->io_port, IO_RANGE);
3623 release_region(setup->io_port, IO_RANGE);
3625 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3628 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3631 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3634 if ((setup->parity < 0) || (setup->parity > 1))
3637 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3640 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3648 static int __init aha152x_init(void)
3651 #if defined(AUTOCONF)
3652 aha152x_config conf;
3655 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3658 if ( setup_count ) {
3659 printk(KERN_INFO "aha152x: processing commandline: ");
3661 for (i = 0; i<setup_count; i++) {
3662 if (!checksetup(&setup[i])) {
3663 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3664 printk(KERN_ERR "aha152x: invalid line\n");
3671 if (setup_count < ARRAY_SIZE(setup)) {
3672 struct aha152x_setup override = SETUP0;
3674 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3675 if (!checksetup(&override)) {
3676 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3682 override.synchronous,
3684 override.ext_trans);
3686 setup[setup_count++] = override;
3692 if (setup_count < ARRAY_SIZE(setup)) {
3693 struct aha152x_setup override = SETUP1;
3695 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3696 if (!checksetup(&override)) {
3697 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3703 override.synchronous,
3705 override.ext_trans);
3707 setup[setup_count++] = override;
3713 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3715 setup[setup_count].conf = "";
3716 setup[setup_count].io_port = aha152x[0];
3717 setup[setup_count].irq = aha152x[1];
3718 setup[setup_count].scsiid = aha152x[2];
3719 setup[setup_count].reconnect = aha152x[3];
3720 setup[setup_count].parity = aha152x[4];
3721 setup[setup_count].synchronous = aha152x[5];
3722 setup[setup_count].delay = aha152x[6];
3723 setup[setup_count].ext_trans = aha152x[7];
3724 #if defined(AHA152X_DEBUG)
3725 setup[setup_count].debug = aha152x[8];
3727 } else if(io[0]!=0 || irq[0]!=0) {
3728 if(io[0]!=0) setup[setup_count].io_port = io[0];
3729 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3731 setup[setup_count].scsiid = scsiid[0];
3732 setup[setup_count].reconnect = reconnect[0];
3733 setup[setup_count].parity = parity[0];
3734 setup[setup_count].synchronous = sync[0];
3735 setup[setup_count].delay = delay[0];
3736 setup[setup_count].ext_trans = exttrans[0];
3737 #if defined(AHA152X_DEBUG)
3738 setup[setup_count].debug = debug[0];
3742 if (checksetup(&setup[setup_count]))
3745 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",
3746 setup[setup_count].io_port,
3747 setup[setup_count].irq,
3748 setup[setup_count].scsiid,
3749 setup[setup_count].reconnect,
3750 setup[setup_count].parity,
3751 setup[setup_count].synchronous,
3752 setup[setup_count].delay,
3753 setup[setup_count].ext_trans);
3756 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3757 if(aha152x1[0]!=0) {
3758 setup[setup_count].conf = "";
3759 setup[setup_count].io_port = aha152x1[0];
3760 setup[setup_count].irq = aha152x1[1];
3761 setup[setup_count].scsiid = aha152x1[2];
3762 setup[setup_count].reconnect = aha152x1[3];
3763 setup[setup_count].parity = aha152x1[4];
3764 setup[setup_count].synchronous = aha152x1[5];
3765 setup[setup_count].delay = aha152x1[6];
3766 setup[setup_count].ext_trans = aha152x1[7];
3767 #if defined(AHA152X_DEBUG)
3768 setup[setup_count].debug = aha152x1[8];
3770 } else if(io[1]!=0 || irq[1]!=0) {
3771 if(io[1]!=0) setup[setup_count].io_port = io[1];
3772 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3774 setup[setup_count].scsiid = scsiid[1];
3775 setup[setup_count].reconnect = reconnect[1];
3776 setup[setup_count].parity = parity[1];
3777 setup[setup_count].synchronous = sync[1];
3778 setup[setup_count].delay = delay[1];
3779 setup[setup_count].ext_trans = exttrans[1];
3780 #if defined(AHA152X_DEBUG)
3781 setup[setup_count].debug = debug[1];
3784 if (checksetup(&setup[setup_count]))
3787 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",
3788 setup[setup_count].io_port,
3789 setup[setup_count].irq,
3790 setup[setup_count].scsiid,
3791 setup[setup_count].reconnect,
3792 setup[setup_count].parity,
3793 setup[setup_count].synchronous,
3794 setup[setup_count].delay,
3795 setup[setup_count].ext_trans);
3800 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3801 while ( setup_count<ARRAY_SIZE(setup) &&
3802 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3803 if (pnp_device_attach(dev) < 0)
3806 if (pnp_activate_dev(dev) < 0) {
3807 pnp_device_detach(dev);
3811 if (!pnp_port_valid(dev, 0)) {
3812 pnp_device_detach(dev);
3816 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3817 pnp_device_detach(dev);
3821 setup[setup_count].io_port = pnp_port_start(dev, 0);
3822 setup[setup_count].irq = pnp_irq(dev, 0);
3823 setup[setup_count].scsiid = 7;
3824 setup[setup_count].reconnect = 1;
3825 setup[setup_count].parity = 1;
3826 setup[setup_count].synchronous = 1;
3827 setup[setup_count].delay = DELAY_DEFAULT;
3828 setup[setup_count].ext_trans = 0;
3829 #if defined(AHA152X_DEBUG)
3830 setup[setup_count].debug = DEBUG_DEFAULT;
3832 #if defined(__ISAPNP__)
3833 pnpdev[setup_count] = dev;
3836 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3837 setup[setup_count].io_port, setup[setup_count].irq);
3843 #if defined(AUTOCONF)
3844 if (setup_count<ARRAY_SIZE(setup)) {
3845 #if !defined(SKIP_BIOSTEST)
3847 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3848 void __iomem *p = ioremap(addresses[i], 0x4000);
3851 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3852 ok = check_signature(p + signatures[j].sig_offset,
3853 signatures[j].signature, signatures[j].sig_length);
3856 if (!ok && setup_count == 0)
3859 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3861 printk(KERN_INFO "aha152x: ");
3862 #endif /* !SKIP_BIOSTEST */
3865 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3866 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3869 if ( request_region(ports[i], IO_RANGE, "aha152x")==0 ) {
3870 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3874 if (aha152x_porttest(ports[i])) {
3875 setup[setup_count].tc1550 = 0;
3878 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3879 } else if (tc1550_porttest(ports[i])) {
3880 setup[setup_count].tc1550 = 1;
3883 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3885 release_region(ports[i], IO_RANGE);
3889 release_region(ports[i], IO_RANGE);
3892 setup[setup_count].io_port = ports[i];
3893 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3894 setup[setup_count].scsiid = conf.cf_id;
3895 setup[setup_count].reconnect = conf.cf_tardisc;
3896 setup[setup_count].parity = !conf.cf_parity;
3897 setup[setup_count].synchronous = conf.cf_syncneg;
3898 setup[setup_count].delay = DELAY_DEFAULT;
3899 setup[setup_count].ext_trans = 0;
3900 #if defined(AHA152X_DEBUG)
3901 setup[setup_count].debug = DEBUG_DEFAULT;
3908 printk("auto configuration: ok, ");
3912 printk("%d controller(s) configured\n", setup_count);
3914 for (i=0; i<setup_count; i++) {
3915 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3916 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3919 release_region(setup[i].io_port, IO_RANGE);
3920 #if defined(__ISAPNP__)
3921 } else if( pnpdev[i] ) {
3922 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3927 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3930 #if defined(__ISAPNP__)
3932 pnp_device_detach(pnpdev[i]);
3939 static void __exit aha152x_exit(void)
3941 struct aha152x_hostdata *hd;
3943 list_for_each_entry(hd, &aha152x_host_list, host_list) {
3944 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3946 aha152x_release(shost);
3950 module_init(aha152x_init);
3951 module_exit(aha152x_exit);
3953 #if !defined(MODULE)
3954 static int __init aha152x_setup(char *str)
3956 #if defined(AHA152X_DEBUG)
3961 get_options(str, ARRAY_SIZE(ints), ints);
3963 if(setup_count>=ARRAY_SIZE(setup)) {
3964 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3968 setup[setup_count].conf = str;
3969 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3970 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3971 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3972 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3973 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3974 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3975 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3976 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3977 #if defined(AHA152X_DEBUG)
3978 setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3980 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3981 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3983 if (ints[0] > 8) { /*}*/
3984 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3985 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3994 __setup("aha152x=", aha152x_setup);
3997 #endif /* !PCMCIA */