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>
267 /* For PCMCIA cards, always use AUTOCONF */
268 #if defined(PCMCIA) || defined(MODULE)
269 #if !defined(AUTOCONF)
274 #if !defined(AUTOCONF) && !defined(SETUP0)
275 #error define AUTOCONF or SETUP0
278 #if defined(AHA152X_DEBUG)
279 #define DEBUG_DEFAULT debug_eh
281 #define DPRINTK(when,msgs...) \
282 do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
284 #define DO_LOCK(flags) \
286 if(spin_is_locked(&QLOCK)) { \
287 DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
289 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
290 spin_lock_irqsave(&QLOCK,flags); \
291 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
292 QLOCKER=__FUNCTION__; \
296 #define DO_UNLOCK(flags) \
298 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__, QLOCKER, QLOCKERL); \
299 spin_unlock_irqrestore(&QLOCK,flags); \
300 DPRINTK(debug_locks, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __FUNCTION__, __LINE__); \
301 QLOCKER="(not locked)"; \
306 #define DPRINTK(when,msgs...)
307 #define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
308 #define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
311 #define LEAD "(scsi%d:%d:%d) "
312 #define WARN_LEAD KERN_WARNING LEAD
313 #define INFO_LEAD KERN_INFO LEAD
314 #define NOTE_LEAD KERN_NOTICE LEAD
315 #define ERR_LEAD KERN_ERR LEAD
316 #define DEBUG_LEAD KERN_DEBUG LEAD
317 #define CMDINFO(cmd) \
318 (cmd) ? ((cmd)->device->host->host_no) : -1, \
319 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
320 (cmd) ? ((cmd)->device->lun & 0x07) : -1
322 #define DELAY_DEFAULT 1000
330 #define IRQ_MAX (NR_IRQS-1)
337 not_issued
= 0x0001, /* command not yet issued */
338 selecting
= 0x0002, /* target is beeing selected */
339 identified
= 0x0004, /* IDENTIFY was sent */
340 disconnected
= 0x0008, /* target disconnected */
341 completed
= 0x0010, /* target sent COMMAND COMPLETE */
342 aborted
= 0x0020, /* ABORT was sent */
343 resetted
= 0x0040, /* BUS DEVICE RESET was sent */
344 spiordy
= 0x0080, /* waiting for SPIORDY to raise */
345 syncneg
= 0x0100, /* synchronous negotiation in progress */
346 aborting
= 0x0200, /* ABORT is pending */
347 resetting
= 0x0400, /* BUS DEVICE RESET is pending */
348 check_condition
= 0x0800, /* requesting sense after CHECK CONDITION */
351 MODULE_AUTHOR("Jürgen Fischer");
352 MODULE_DESCRIPTION(AHA152X_REVID
);
353 MODULE_LICENSE("GPL");
357 static int io
[] = {0, 0};
358 module_param_array(io
, int, NULL
, 0);
359 MODULE_PARM_DESC(io
,"base io address of controller");
361 static int irq
[] = {0, 0};
362 module_param_array(irq
, int, NULL
, 0);
363 MODULE_PARM_DESC(irq
,"interrupt for controller");
365 static int scsiid
[] = {7, 7};
366 module_param_array(scsiid
, int, NULL
, 0);
367 MODULE_PARM_DESC(scsiid
,"scsi id of controller");
369 static int reconnect
[] = {1, 1};
370 module_param_array(reconnect
, int, NULL
, 0);
371 MODULE_PARM_DESC(reconnect
,"allow targets to disconnect");
373 static int parity
[] = {1, 1};
374 module_param_array(parity
, int, NULL
, 0);
375 MODULE_PARM_DESC(parity
,"use scsi parity");
377 static int sync
[] = {1, 1};
378 module_param_array(sync
, int, NULL
, 0);
379 MODULE_PARM_DESC(sync
,"use synchronous transfers");
381 static int delay
[] = {DELAY_DEFAULT
, DELAY_DEFAULT
};
382 module_param_array(delay
, int, NULL
, 0);
383 MODULE_PARM_DESC(delay
,"scsi reset delay");
385 static int exttrans
[] = {0, 0};
386 module_param_array(exttrans
, int, NULL
, 0);
387 MODULE_PARM_DESC(exttrans
,"use extended translation");
389 #if !defined(AHA152X_DEBUG)
390 static int aha152x
[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT
, 0};
391 module_param_array(aha152x
, int, NULL
, 0);
392 MODULE_PARM_DESC(aha152x
, "parameters for first controller");
394 static int aha152x1
[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT
, 0};
395 module_param_array(aha152x1
, int, NULL
, 0);
396 MODULE_PARM_DESC(aha152x1
, "parameters for second controller");
398 static int debug
[] = {DEBUG_DEFAULT
, DEBUG_DEFAULT
};
399 module_param_array(debug
, int, NULL
, 0);
400 MODULE_PARM_DESC(debug
, "flags for driver debugging");
402 static int aha152x
[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT
, 0, DEBUG_DEFAULT
};
403 module_param_array(aha152x
, int, NULL
, 0);
404 MODULE_PARM_DESC(aha152x
, "parameters for first controller");
406 static int aha152x1
[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT
, 0, DEBUG_DEFAULT
};
407 module_param_array(aha152x1
, int, NULL
, 0);
408 MODULE_PARM_DESC(aha152x1
, "parameters for second controller");
409 #endif /* !defined(AHA152X_DEBUG) */
413 static struct isapnp_device_id id_table
[] __devinitdata
= {
414 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
415 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1505), 0 },
416 { ISAPNP_ANY_ID
, ISAPNP_ANY_ID
,
417 ISAPNP_VENDOR('A','D','P'), ISAPNP_FUNCTION(0x1530), 0 },
418 { ISAPNP_DEVICE_SINGLE_END
, }
420 MODULE_DEVICE_TABLE(isapnp
, id_table
);
425 static int registered_count
=0;
426 static struct Scsi_Host
*aha152x_host
[2];
427 static struct scsi_host_template aha152x_driver_template
;
430 * internal states of the host
452 * current state information of the host
455 struct aha152x_hostdata
{
457 /* pending commands to issue */
459 Scsi_Cmnd
*current_SC
;
460 /* current command on the bus */
462 Scsi_Cmnd
*disconnected_SC
;
463 /* commands that disconnected */
466 /* command that was completed */
471 #if defined(AHA152X_DEBUG)
473 /* which function has the lock */
474 int lockerl
; /* where did it get it */
476 int debug
; /* current debugging setting */
479 #if defined(AHA152X_STAT)
482 int busfree_without_any_action
;
483 int busfree_without_old_command
;
484 int busfree_without_new_command
;
485 int busfree_without_done_command
;
486 int busfree_with_check_condition
;
488 int count_trans
[maxstate
];
489 unsigned long time
[maxstate
];
492 int commands
; /* current number of commands */
494 int reconnect
; /* disconnection allowed */
495 int parity
; /* parity checking enabled */
496 int synchronous
; /* synchronous transferes enabled */
497 int delay
; /* reset out delay */
498 int ext_trans
; /* extended translation enabled */
500 int swint
; /* software-interrupt was fired during detect() */
501 int service
; /* bh needs to be run */
502 int in_intr
; /* bh is running */
506 last state different from current state */
507 enum aha152x_state state
, prevstate
, laststate
;
510 /* reconnecting target */
512 unsigned char syncrate
[8];
513 /* current synchronous transfer agreements */
515 unsigned char syncneg
[8];
516 /* 0: no negotiation;
517 * 1: negotiation in progress;
518 * 2: negotiation completed
522 /* number of sent bytes of current command */
525 /* number of received message bytes */
526 unsigned char msgi
[256];
527 /* received message bytes */
529 int msgo_i
, msgo_len
;
530 /* number of sent bytes and length of current messages */
531 unsigned char msgo
[256];
532 /* pending messages */
535 /* number of sent/received bytes in dataphase */
537 unsigned long io_port0
;
538 unsigned long io_port1
;
541 struct pnp_dev
*pnpdev
;
547 * host specific command extension
550 struct aha152x_scdata
{
551 Scsi_Cmnd
*next
; /* next sc in queue */
552 struct semaphore
*sem
; /* semaphore to block on */
556 /* access macros for hostdata */
558 #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
560 #define HOSTNO ((shpnt)->host_no)
562 #define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
563 #define DONE_SC (HOSTDATA(shpnt)->done_SC)
564 #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
565 #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
566 #define QLOCK (HOSTDATA(shpnt)->lock)
567 #define QLOCKER (HOSTDATA(shpnt)->locker)
568 #define QLOCKERL (HOSTDATA(shpnt)->lockerl)
570 #define STATE (HOSTDATA(shpnt)->state)
571 #define PREVSTATE (HOSTDATA(shpnt)->prevstate)
572 #define LASTSTATE (HOSTDATA(shpnt)->laststate)
574 #define RECONN_TARGET (HOSTDATA(shpnt)->target)
576 #define CMD_I (HOSTDATA(shpnt)->cmd_i)
578 #define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
579 #define MSGO_I (HOSTDATA(shpnt)->msgo_i)
580 #define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
581 #define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
583 #define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
584 #define MSGILEN (HOSTDATA(shpnt)->msgi_len)
585 #define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
587 #define DATA_LEN (HOSTDATA(shpnt)->data_len)
589 #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
590 #define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
592 #define DELAY (HOSTDATA(shpnt)->delay)
593 #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
594 #define TC1550 (HOSTDATA(shpnt)->tc1550)
595 #define RECONNECT (HOSTDATA(shpnt)->reconnect)
596 #define PARITY (HOSTDATA(shpnt)->parity)
597 #define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
599 #define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
600 #define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
602 #define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
603 #define SCNEXT(SCpnt) SCDATA(SCpnt)->next
604 #define SCSEM(SCpnt) SCDATA(SCpnt)->sem
606 #define SG_ADDRESS(buffer) ((char *) (page_address((buffer)->page)+(buffer)->offset))
609 static void seldi_run(struct Scsi_Host
*shpnt
);
610 static void seldo_run(struct Scsi_Host
*shpnt
);
611 static void selto_run(struct Scsi_Host
*shpnt
);
612 static void busfree_run(struct Scsi_Host
*shpnt
);
614 static void msgo_init(struct Scsi_Host
*shpnt
);
615 static void msgo_run(struct Scsi_Host
*shpnt
);
616 static void msgo_end(struct Scsi_Host
*shpnt
);
618 static void cmd_init(struct Scsi_Host
*shpnt
);
619 static void cmd_run(struct Scsi_Host
*shpnt
);
620 static void cmd_end(struct Scsi_Host
*shpnt
);
622 static void datai_init(struct Scsi_Host
*shpnt
);
623 static void datai_run(struct Scsi_Host
*shpnt
);
624 static void datai_end(struct Scsi_Host
*shpnt
);
626 static void datao_init(struct Scsi_Host
*shpnt
);
627 static void datao_run(struct Scsi_Host
*shpnt
);
628 static void datao_end(struct Scsi_Host
*shpnt
);
630 static void status_run(struct Scsi_Host
*shpnt
);
632 static void msgi_run(struct Scsi_Host
*shpnt
);
633 static void msgi_end(struct Scsi_Host
*shpnt
);
635 static void parerr_run(struct Scsi_Host
*shpnt
);
636 static void rsti_run(struct Scsi_Host
*shpnt
);
638 static void is_complete(struct Scsi_Host
*shpnt
);
646 void (*init
)(struct Scsi_Host
*);
647 void (*run
)(struct Scsi_Host
*);
648 void (*end
)(struct Scsi_Host
*);
651 { "idle", NULL
, NULL
, NULL
, 0},
652 { "unknown", NULL
, NULL
, NULL
, 0},
653 { "seldo", NULL
, seldo_run
, NULL
, 0},
654 { "seldi", NULL
, seldi_run
, NULL
, 0},
655 { "selto", NULL
, selto_run
, NULL
, 0},
656 { "busfree", NULL
, busfree_run
, NULL
, 0},
657 { "msgo", msgo_init
, msgo_run
, msgo_end
, 1},
658 { "cmd", cmd_init
, cmd_run
, cmd_end
, 1},
659 { "msgi", NULL
, msgi_run
, msgi_end
, 1},
660 { "status", NULL
, status_run
, NULL
, 1},
661 { "datai", datai_init
, datai_run
, datai_end
, 0},
662 { "datao", datao_init
, datao_run
, datao_end
, 0},
663 { "parerr", NULL
, parerr_run
, NULL
, 0},
664 { "rsti", NULL
, rsti_run
, NULL
, 0},
667 /* setup & interrupt */
668 static irqreturn_t
intr(int irq
, void *dev_id
, struct pt_regs
*);
669 static void reset_ports(struct Scsi_Host
*shpnt
);
670 static void aha152x_error(struct Scsi_Host
*shpnt
, char *msg
);
671 static void done(struct Scsi_Host
*shpnt
, int error
);
674 static void disp_ports(struct Scsi_Host
*shpnt
);
675 static void show_command(Scsi_Cmnd
* ptr
);
676 static void show_queues(struct Scsi_Host
*shpnt
);
677 static void disp_enintr(struct Scsi_Host
*shpnt
);
684 static inline void append_SC(Scsi_Cmnd
**SC
, Scsi_Cmnd
*new_SC
)
688 SCNEXT(new_SC
) = NULL
;
692 for (end
= *SC
; SCNEXT(end
); end
= SCNEXT(end
))
694 SCNEXT(end
) = new_SC
;
698 static inline Scsi_Cmnd
*remove_first_SC(Scsi_Cmnd
** SC
)
710 static inline Scsi_Cmnd
*remove_lun_SC(Scsi_Cmnd
** SC
, int target
, int lun
)
712 Scsi_Cmnd
*ptr
, *prev
;
714 for (ptr
= *SC
, prev
= NULL
;
715 ptr
&& ((ptr
->device
->id
!= target
) || (ptr
->device
->lun
!= lun
));
716 prev
= ptr
, ptr
= SCNEXT(ptr
))
721 SCNEXT(prev
) = SCNEXT(ptr
);
731 static inline Scsi_Cmnd
*remove_SC(Scsi_Cmnd
**SC
, Scsi_Cmnd
*SCp
)
733 Scsi_Cmnd
*ptr
, *prev
;
735 for (ptr
= *SC
, prev
= NULL
;
737 prev
= ptr
, ptr
= SCNEXT(ptr
))
742 SCNEXT(prev
) = SCNEXT(ptr
);
752 static inline struct Scsi_Host
*lookup_irq(int irqno
)
756 for(i
=0; i
<ARRAY_SIZE(aha152x_host
); i
++)
757 if(aha152x_host
[i
] && aha152x_host
[i
]->irq
==irqno
)
758 return aha152x_host
[i
];
763 static irqreturn_t
swintr(int irqno
, void *dev_id
, struct pt_regs
*regs
)
765 struct Scsi_Host
*shpnt
= lookup_irq(irqno
);
768 printk(KERN_ERR
"aha152x: catched software interrupt %d for unknown controller.\n", irqno
);
772 HOSTDATA(shpnt
)->swint
++;
774 SETPORT(DMACNTRL0
, INTEN
);
778 struct Scsi_Host
*aha152x_probe_one(struct aha152x_setup
*setup
)
780 struct Scsi_Host
*shpnt
;
782 shpnt
= scsi_host_alloc(&aha152x_driver_template
, sizeof(struct aha152x_hostdata
));
784 printk(KERN_ERR
"aha152x: scsi_host_alloc failed\n");
788 /* need to have host registered before triggering any interrupt */
789 aha152x_host
[registered_count
] = shpnt
;
791 memset(HOSTDATA(shpnt
), 0, sizeof *HOSTDATA(shpnt
));
793 shpnt
->io_port
= setup
->io_port
;
794 shpnt
->n_io_port
= IO_RANGE
;
795 shpnt
->irq
= setup
->irq
;
797 if (!setup
->tc1550
) {
798 HOSTIOPORT0
= setup
->io_port
;
799 HOSTIOPORT1
= setup
->io_port
;
801 HOSTIOPORT0
= setup
->io_port
+0x10;
802 HOSTIOPORT1
= setup
->io_port
-0x10;
805 spin_lock_init(&QLOCK
);
806 RECONNECT
= setup
->reconnect
;
807 SYNCHRONOUS
= setup
->synchronous
;
808 PARITY
= setup
->parity
;
809 DELAY
= setup
->delay
;
810 EXT_TRANS
= setup
->ext_trans
;
812 #if defined(AHA152X_DEBUG)
813 HOSTDATA(shpnt
)->debug
= setup
->debug
;
816 SETPORT(SCSIID
, setup
->scsiid
<< 4);
817 shpnt
->this_id
= setup
->scsiid
;
819 if (setup
->reconnect
)
820 shpnt
->can_queue
= AHA152X_MAXQUEUE
;
823 printk("aha152x: resetting bus...\n");
824 SETPORT(SCSISEQ
, SCSIRSTO
);
833 "vital data: rev=%x, "
834 "io=0x%03lx (0x%03lx/0x%03lx), "
841 "extended translation=%s\n",
842 shpnt
->host_no
, setup
->tc1550
? " (tc1550 mode)" : "",
844 shpnt
->io_port
, HOSTIOPORT0
, HOSTIOPORT1
,
847 RECONNECT
? "enabled" : "disabled",
848 PARITY
? "enabled" : "disabled",
849 SYNCHRONOUS
? "enabled" : "disabled",
851 EXT_TRANS
? "enabled" : "disabled");
853 /* not expecting any interrupts */
857 if( request_irq(shpnt
->irq
, swintr
, SA_INTERRUPT
|SA_SHIRQ
, "aha152x", shpnt
) ) {
858 printk(KERN_ERR
"aha152x%d: irq %d busy.\n", shpnt
->host_no
, shpnt
->irq
);
862 HOSTDATA(shpnt
)->swint
= 0;
864 printk(KERN_INFO
"aha152x%d: trying software interrupt, ", shpnt
->host_no
);
867 SETPORT(DMACNTRL0
, SWINT
|INTEN
);
869 free_irq(shpnt
->irq
, shpnt
);
871 if (!HOSTDATA(shpnt
)->swint
) {
872 if (TESTHI(DMASTAT
, INTSTAT
)) {
878 SETPORT(DMACNTRL0
, INTEN
);
880 printk(KERN_ERR
"aha152x%d: irq %d possibly wrong. "
881 "Please verify.\n", shpnt
->host_no
, shpnt
->irq
);
887 /* clear interrupts */
888 SETPORT(SSTAT0
, 0x7f);
889 SETPORT(SSTAT1
, 0xef);
891 if ( request_irq(shpnt
->irq
, intr
, SA_INTERRUPT
|SA_SHIRQ
, "aha152x", shpnt
) ) {
892 printk(KERN_ERR
"aha152x%d: failed to reassign irq %d.\n", shpnt
->host_no
, shpnt
->irq
);
896 if( scsi_add_host(shpnt
, NULL
) ) {
897 free_irq(shpnt
->irq
, shpnt
);
898 printk(KERN_ERR
"aha152x%d: failed to add host.\n", shpnt
->host_no
);
902 scsi_scan_host(shpnt
);
909 aha152x_host
[registered_count
]=NULL
;
910 scsi_host_put(shpnt
);
915 void aha152x_release(struct Scsi_Host
*shpnt
)
921 free_irq(shpnt
->irq
, shpnt
);
925 release_region(shpnt
->io_port
, IO_RANGE
);
929 if (HOSTDATA(shpnt
)->pnpdev
)
930 pnp_device_detach(HOSTDATA(shpnt
)->pnpdev
);
933 scsi_remove_host(shpnt
);
934 scsi_host_put(shpnt
);
939 * setup controller to generate interrupts depending
940 * on current state (lock has to be acquired)
943 static int setup_expected_interrupts(struct Scsi_Host
*shpnt
)
946 CURRENT_SC
->SCp
.phase
|= 1 << 16;
948 if(CURRENT_SC
->SCp
.phase
& selecting
) {
949 DPRINTK(debug_intr
, DEBUG_LEAD
"expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC
));
950 SETPORT(SSTAT1
, SELTO
);
951 SETPORT(SIMODE0
, ENSELDO
| (DISCONNECTED_SC
? ENSELDI
: 0));
952 SETPORT(SIMODE1
, ENSELTIMO
);
954 DPRINTK(debug_intr
, DEBUG_LEAD
"expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC
), CURRENT_SC
->SCp
.phase
& spiordy
? "(spiordy)" : "");
955 SETPORT(SIMODE0
, (CURRENT_SC
->SCp
.phase
& spiordy
) ? ENSPIORDY
: 0);
956 SETPORT(SIMODE1
, ENPHASEMIS
| ENSCSIRST
| ENSCSIPERR
| ENBUSFREE
);
958 } else if(STATE
==seldi
) {
959 DPRINTK(debug_intr
, DEBUG_LEAD
"expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC
));
961 SETPORT(SIMODE1
, ENPHASEMIS
| ENSCSIRST
| ENSCSIPERR
| ENBUSFREE
);
963 DPRINTK(debug_intr
, DEBUG_LEAD
"expecting: %s %s\n",
965 DISCONNECTED_SC
? "(reselection)" : "",
966 ISSUE_SC
? "(busfree)" : "");
967 SETPORT(SIMODE0
, DISCONNECTED_SC
? ENSELDI
: 0);
968 SETPORT(SIMODE1
, ENSCSIRST
| ( (ISSUE_SC
||DONE_SC
) ? ENBUSFREE
: 0));
971 if(!HOSTDATA(shpnt
)->in_intr
)
972 SETBITS(DMACNTRL0
, INTEN
);
974 return TESTHI(DMASTAT
, INTSTAT
);
979 * Queue a command and setup interrupts for a free bus.
981 static int aha152x_internal_queue(Scsi_Cmnd
*SCpnt
, struct semaphore
*sem
, int phase
, void (*done
)(Scsi_Cmnd
*))
983 struct Scsi_Host
*shpnt
= SCpnt
->device
->host
;
986 #if defined(AHA152X_DEBUG)
987 if (HOSTDATA(shpnt
)->debug
& debug_queue
) {
988 printk(INFO_LEAD
"queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
989 CMDINFO(SCpnt
), SCpnt
, SCpnt
->cmd_len
, SCpnt
->use_sg
, SCpnt
->request_bufflen
);
990 __scsi_print_command(SCpnt
->cmnd
);
994 SCpnt
->scsi_done
= done
;
995 SCpnt
->resid
= SCpnt
->request_bufflen
;
996 SCpnt
->SCp
.phase
= not_issued
| phase
;
997 SCpnt
->SCp
.Status
= CHECK_CONDITION
;
998 SCpnt
->SCp
.Message
= 0;
999 SCpnt
->SCp
.have_data_in
= 0;
1000 SCpnt
->SCp
.sent_command
= 0;
1002 if(SCpnt
->SCp
.phase
& (resetting
|check_condition
)) {
1003 if(SCpnt
->host_scribble
==0 || SCSEM(SCpnt
) || SCNEXT(SCpnt
)) {
1004 printk(ERR_LEAD
"cannot reuse command\n", CMDINFO(SCpnt
));
1008 SCpnt
->host_scribble
= kmalloc(sizeof(struct aha152x_scdata
), GFP_ATOMIC
);
1009 if(SCpnt
->host_scribble
==0) {
1010 printk(ERR_LEAD
"allocation failed\n", CMDINFO(SCpnt
));
1015 SCNEXT(SCpnt
) = NULL
;
1018 /* setup scratch area
1019 SCp.ptr : buffer pointer
1020 SCp.this_residual : buffer length
1021 SCp.buffer : next buffer
1022 SCp.buffers_residual : left buffers in list
1023 SCp.phase : current state of the command */
1024 if (SCpnt
->use_sg
) {
1025 SCpnt
->SCp
.buffer
= (struct scatterlist
*) SCpnt
->request_buffer
;
1026 SCpnt
->SCp
.ptr
= SG_ADDRESS(SCpnt
->SCp
.buffer
);
1027 SCpnt
->SCp
.this_residual
= SCpnt
->SCp
.buffer
->length
;
1028 SCpnt
->SCp
.buffers_residual
= SCpnt
->use_sg
- 1;
1030 SCpnt
->SCp
.ptr
= (char *) SCpnt
->request_buffer
;
1031 SCpnt
->SCp
.this_residual
= SCpnt
->request_bufflen
;
1032 SCpnt
->SCp
.buffer
= NULL
;
1033 SCpnt
->SCp
.buffers_residual
= 0;
1038 #if defined(AHA152X_STAT)
1039 HOSTDATA(shpnt
)->total_commands
++;
1042 /* Turn led on, when this is the first command. */
1043 HOSTDATA(shpnt
)->commands
++;
1044 if (HOSTDATA(shpnt
)->commands
==1)
1047 append_SC(&ISSUE_SC
, SCpnt
);
1049 if(!HOSTDATA(shpnt
)->in_intr
)
1050 setup_expected_interrupts(shpnt
);
1061 static int aha152x_queue(Scsi_Cmnd
*SCpnt
, void (*done
)(Scsi_Cmnd
*))
1064 if(*SCpnt
->cmnd
== REQUEST_SENSE
) {
1072 return aha152x_internal_queue(SCpnt
, NULL
, 0, done
);
1080 static void reset_done(Scsi_Cmnd
*SCpnt
)
1083 struct Scsi_Host
*shpnt
= SCpnt
->host
;
1084 DPRINTK(debug_eh
, INFO_LEAD
"reset_done called\n", CMDINFO(SCpnt
));
1089 printk(KERN_ERR
"aha152x: reset_done w/o semaphore\n");
1097 static int aha152x_abort(Scsi_Cmnd
*SCpnt
)
1099 struct Scsi_Host
*shpnt
= SCpnt
->device
->host
;
1101 unsigned long flags
;
1103 #if defined(AHA152X_DEBUG)
1104 if(HOSTDATA(shpnt
)->debug
& debug_eh
) {
1105 printk(DEBUG_LEAD
"abort(%p)", CMDINFO(SCpnt
), SCpnt
);
1112 ptr
=remove_SC(&ISSUE_SC
, SCpnt
);
1115 DPRINTK(debug_eh
, DEBUG_LEAD
"not yet issued - SUCCESS\n", CMDINFO(SCpnt
));
1117 HOSTDATA(shpnt
)->commands
--;
1118 if (!HOSTDATA(shpnt
)->commands
)
1122 kfree(SCpnt
->host_scribble
);
1123 SCpnt
->host_scribble
=NULL
;
1132 * for current command: queue ABORT for message out and raise ATN
1133 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1137 printk(ERR_LEAD
"cannot abort running or disconnected command\n", CMDINFO(SCpnt
));
1142 static void timer_expired(unsigned long p
)
1144 Scsi_Cmnd
*SCp
= (Scsi_Cmnd
*)p
;
1145 struct semaphore
*sem
= SCSEM(SCp
);
1146 struct Scsi_Host
*shpnt
= SCp
->device
->host
;
1147 unsigned long flags
;
1149 /* remove command from issue queue */
1151 remove_SC(&ISSUE_SC
, SCp
);
1161 static int aha152x_device_reset(Scsi_Cmnd
* SCpnt
)
1163 struct Scsi_Host
*shpnt
= SCpnt
->device
->host
;
1164 DECLARE_MUTEX_LOCKED(sem
);
1165 struct timer_list timer
;
1166 int ret
, issued
, disconnected
;
1167 unsigned long flags
;
1169 #if defined(AHA152X_DEBUG)
1170 if(HOSTDATA(shpnt
)->debug
& debug_eh
) {
1171 printk(INFO_LEAD
"aha152x_device_reset(%p)", CMDINFO(SCpnt
), SCpnt
);
1176 if(CURRENT_SC
==SCpnt
) {
1177 printk(ERR_LEAD
"cannot reset current device\n", CMDINFO(SCpnt
));
1182 issued
= remove_SC(&ISSUE_SC
, SCpnt
)==0;
1183 disconnected
= issued
&& remove_SC(&DISCONNECTED_SC
, SCpnt
);
1188 SCpnt
->request_buffer
= NULL
;
1189 SCpnt
->request_bufflen
= 0;
1192 timer
.data
= (unsigned long) SCpnt
;
1193 timer
.expires
= jiffies
+ 100*HZ
; /* 10s */
1194 timer
.function
= (void (*)(unsigned long)) timer_expired
;
1196 aha152x_internal_queue(SCpnt
, &sem
, resetting
, reset_done
);
1201 SCpnt
->cmd_len
= SCpnt
->old_cmd_len
;
1202 SCpnt
->use_sg
= SCpnt
->old_use_sg
;
1203 SCpnt
->request_buffer
= SCpnt
->buffer
;
1204 SCpnt
->request_bufflen
= SCpnt
->bufflen
;
1208 if(SCpnt
->SCp
.phase
& resetted
) {
1209 HOSTDATA(shpnt
)->commands
--;
1210 if (!HOSTDATA(shpnt
)->commands
)
1212 kfree(SCpnt
->host_scribble
);
1213 SCpnt
->host_scribble
=NULL
;
1219 append_SC(&ISSUE_SC
, SCpnt
);
1220 } else if(disconnected
) {
1221 append_SC(&DISCONNECTED_SC
, SCpnt
);
1231 static void free_hard_reset_SCs(struct Scsi_Host
*shpnt
, Scsi_Cmnd
**SCs
)
1242 printk(DEBUG_LEAD
"queue corrupted at %p\n", CMDINFO(ptr
), ptr
);
1246 if (!ptr
->device
->soft_reset
) {
1247 DPRINTK(debug_eh
, DEBUG_LEAD
"disconnected command %p removed\n", CMDINFO(ptr
), ptr
);
1248 remove_SC(SCs
, ptr
);
1249 HOSTDATA(shpnt
)->commands
--;
1250 kfree(ptr
->host_scribble
);
1251 ptr
->host_scribble
=NULL
;
1262 static int aha152x_bus_reset(Scsi_Cmnd
*SCpnt
)
1264 struct Scsi_Host
*shpnt
= SCpnt
->device
->host
;
1265 unsigned long flags
;
1269 #if defined(AHA152X_DEBUG)
1270 if(HOSTDATA(shpnt
)->debug
& debug_eh
) {
1271 printk(DEBUG_LEAD
"aha152x_bus_reset(%p)", CMDINFO(SCpnt
), SCpnt
);
1276 free_hard_reset_SCs(shpnt
, &ISSUE_SC
);
1277 free_hard_reset_SCs(shpnt
, &DISCONNECTED_SC
);
1279 DPRINTK(debug_eh
, DEBUG_LEAD
"resetting bus\n", CMDINFO(SCpnt
));
1281 SETPORT(SCSISEQ
, SCSIRSTO
);
1283 SETPORT(SCSISEQ
, 0);
1286 DPRINTK(debug_eh
, DEBUG_LEAD
"bus resetted\n", CMDINFO(SCpnt
));
1288 setup_expected_interrupts(shpnt
);
1289 if(HOSTDATA(shpnt
)->commands
==0)
1299 * Restore default values to the AIC-6260 registers and reset the fifos
1302 static void reset_ports(struct Scsi_Host
*shpnt
)
1304 unsigned long flags
;
1306 /* disable interrupts */
1307 SETPORT(DMACNTRL0
, RSTFIFO
);
1309 SETPORT(SCSISEQ
, 0);
1311 SETPORT(SXFRCTL1
, 0);
1312 SETPORT(SCSISIG
, 0);
1315 /* clear all interrupt conditions */
1316 SETPORT(SSTAT0
, 0x7f);
1317 SETPORT(SSTAT1
, 0xef);
1319 SETPORT(SSTAT4
, SYNCERR
| FWERR
| FRERR
);
1321 SETPORT(DMACNTRL0
, 0);
1322 SETPORT(DMACNTRL1
, 0);
1324 SETPORT(BRSTCNTRL
, 0xf1);
1326 /* clear SCSI fifos and transfer count */
1327 SETPORT(SXFRCTL0
, CH1
|CLRCH1
|CLRSTCNT
);
1328 SETPORT(SXFRCTL0
, CH1
);
1331 setup_expected_interrupts(shpnt
);
1336 * Reset the host (bus and controller)
1339 int aha152x_host_reset(Scsi_Cmnd
* SCpnt
)
1341 #if defined(AHA152X_DEBUG)
1342 struct Scsi_Host
*shpnt
= SCpnt
->device
->host
;
1345 DPRINTK(debug_eh
, DEBUG_LEAD
"aha152x_host_reset(%p)\n", CMDINFO(SCpnt
), SCpnt
);
1347 aha152x_bus_reset(SCpnt
);
1349 DPRINTK(debug_eh
, DEBUG_LEAD
"resetting ports\n", CMDINFO(SCpnt
));
1350 reset_ports(SCpnt
->device
->host
);
1356 * Return the "logical geometry"
1359 static int aha152x_biosparam(struct scsi_device
*sdev
, struct block_device
*bdev
,
1360 sector_t capacity
, int *info_array
)
1362 struct Scsi_Host
*shpnt
= sdev
->host
;
1364 /* try default translation */
1367 info_array
[2] = (unsigned long)capacity
/ (64 * 32);
1369 /* for disks >1GB do some guessing */
1370 if (info_array
[2] >= 1024) {
1373 /* try to figure out the geometry from the partition table */
1374 if (scsicam_bios_param(bdev
, capacity
, info
) < 0 ||
1375 !((info
[0] == 64 && info
[1] == 32) || (info
[0] == 255 && info
[1] == 63))) {
1378 "aha152x: unable to verify geometry for disk with >1GB.\n"
1379 " using extended translation.\n");
1380 info_array
[0] = 255;
1382 info_array
[2] = (unsigned long)capacity
/ (255 * 63);
1385 "aha152x: unable to verify geometry for disk with >1GB.\n"
1386 " Using default translation. Please verify yourself.\n"
1387 " Perhaps you need to enable extended translation in the driver.\n"
1388 " See Documentation/scsi/aha152x.txt for details.\n");
1391 info_array
[0] = info
[0];
1392 info_array
[1] = info
[1];
1393 info_array
[2] = info
[2];
1395 if (info
[0] == 255 && !EXT_TRANS
) {
1397 "aha152x: current partition table is using extended translation.\n"
1398 " using it also, although it's not explicitly enabled.\n");
1407 * Internal done function
1410 static void done(struct Scsi_Host
*shpnt
, int error
)
1414 printk(ERR_LEAD
"there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC
), DONE_SC
);
1416 DONE_SC
= CURRENT_SC
;
1418 DONE_SC
->result
= error
;
1420 printk(KERN_ERR
"aha152x: done() called outside of command\n");
1423 static struct work_struct aha152x_tq
;
1426 * Run service completions on the card with interrupts enabled.
1429 static void run(void)
1432 for (i
= 0; i
<ARRAY_SIZE(aha152x_host
); i
++) {
1433 struct Scsi_Host
*shpnt
= aha152x_host
[i
];
1434 if (shpnt
&& HOSTDATA(shpnt
)->service
) {
1435 HOSTDATA(shpnt
)->service
=0;
1442 * Interrupts handler
1446 static irqreturn_t
intr(int irqno
, void *dev_id
, struct pt_regs
*regs
)
1448 struct Scsi_Host
*shpnt
= lookup_irq(irqno
);
1449 unsigned char rev
, dmacntrl0
;
1452 printk(KERN_ERR
"aha152x: catched interrupt %d for unknown controller.\n", irqno
);
1457 * Read a couple of registers that are known to not be all 1's. If
1458 * we read all 1's (-1), that means that either:
1460 * a. The host adapter chip has gone bad, and we cannot control it,
1462 * b. The host adapter is a PCMCIA card that has been ejected
1464 * In either case, we cannot do anything with the host adapter at
1465 * this point in time. So just ignore the interrupt and return.
1466 * In the latter case, the interrupt might actually be meant for
1467 * someone else sharing this IRQ, and that driver will handle it.
1470 dmacntrl0
= GETPORT(DMACNTRL0
);
1471 if ((rev
== 0xFF) && (dmacntrl0
== 0xFF))
1474 /* no more interrupts from the controller, while we're busy.
1475 INTEN is restored by the BH handler */
1476 CLRBITS(DMACNTRL0
, INTEN
);
1479 /* check if there is already something to be
1480 serviced; should not happen */
1481 if(HOSTDATA(shpnt
)->service
) {
1482 printk(KERN_ERR
"aha152x%d: lost interrupt (%d)\n", HOSTNO
, HOSTDATA(shpnt
)->service
);
1487 /* Poke the BH handler */
1488 HOSTDATA(shpnt
)->service
++;
1489 INIT_WORK(&aha152x_tq
, (void *) run
, NULL
);
1490 schedule_work(&aha152x_tq
);
1496 * - handle completition/disconnection/error of current command
1497 * - start selection for next command (if any)
1499 static void busfree_run(struct Scsi_Host
*shpnt
)
1501 unsigned long flags
;
1502 #if defined(AHA152X_STAT)
1506 SETPORT(SXFRCTL0
, CH1
|CLRCH1
|CLRSTCNT
);
1507 SETPORT(SXFRCTL0
, CH1
);
1509 SETPORT(SSTAT1
, CLRBUSFREE
);
1512 #if defined(AHA152X_STAT)
1515 CURRENT_SC
->SCp
.phase
&= ~syncneg
;
1517 if(CURRENT_SC
->SCp
.phase
& completed
) {
1518 /* target sent COMMAND COMPLETE */
1519 done(shpnt
, (CURRENT_SC
->SCp
.Status
& 0xff) | ((CURRENT_SC
->SCp
.Message
& 0xff) << 8) | (DID_OK
<< 16));
1521 } else if(CURRENT_SC
->SCp
.phase
& aborted
) {
1522 DPRINTK(debug_eh
, DEBUG_LEAD
"ABORT sent\n", CMDINFO(CURRENT_SC
));
1523 done(shpnt
, (CURRENT_SC
->SCp
.Status
& 0xff) | ((CURRENT_SC
->SCp
.Message
& 0xff) << 8) | (DID_ABORT
<< 16));
1525 } else if(CURRENT_SC
->SCp
.phase
& resetted
) {
1526 DPRINTK(debug_eh
, DEBUG_LEAD
"BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC
));
1527 done(shpnt
, (CURRENT_SC
->SCp
.Status
& 0xff) | ((CURRENT_SC
->SCp
.Message
& 0xff) << 8) | (DID_RESET
<< 16));
1529 } else if(CURRENT_SC
->SCp
.phase
& disconnected
) {
1530 /* target sent DISCONNECT */
1531 DPRINTK(debug_selection
, DEBUG_LEAD
"target disconnected at %d/%d\n",
1532 CMDINFO(CURRENT_SC
),
1534 CURRENT_SC
->request_bufflen
);
1535 #if defined(AHA152X_STAT)
1536 HOSTDATA(shpnt
)->disconnections
++;
1538 append_SC(&DISCONNECTED_SC
, CURRENT_SC
);
1539 CURRENT_SC
->SCp
.phase
|= 1 << 16;
1543 done(shpnt
, DID_ERROR
<< 16);
1545 #if defined(AHA152X_STAT)
1547 HOSTDATA(shpnt
)->busfree_without_old_command
++;
1554 #if defined(AHA152X_STAT)
1558 if(DONE_SC
->SCp
.phase
& check_condition
) {
1560 if(HOSTDATA(shpnt
)->debug
& debug_eh
) {
1561 printk(ERR_LEAD
"received sense: ", CMDINFO(DONE_SC
));
1562 scsi_print_sense("bh", DONE_SC
);
1566 /* restore old command */
1567 memcpy((void *) DONE_SC
->cmnd
, (void *) DONE_SC
->data_cmnd
, sizeof(DONE_SC
->data_cmnd
));
1568 DONE_SC
->request_buffer
= DONE_SC
->buffer
;
1569 DONE_SC
->request_bufflen
= DONE_SC
->bufflen
;
1570 DONE_SC
->use_sg
= DONE_SC
->old_use_sg
;
1571 DONE_SC
->cmd_len
= DONE_SC
->old_cmd_len
;
1573 DONE_SC
->SCp
.Status
= 0x02;
1575 HOSTDATA(shpnt
)->commands
--;
1576 if (!HOSTDATA(shpnt
)->commands
)
1577 SETPORT(PORTA
, 0); /* turn led off */
1578 } else if(DONE_SC
->SCp
.Status
==0x02) {
1579 #if defined(AHA152X_STAT)
1580 HOSTDATA(shpnt
)->busfree_with_check_condition
++;
1583 DPRINTK(debug_eh
, ERR_LEAD
"CHECK CONDITION found\n", CMDINFO(DONE_SC
));
1586 if(!(DONE_SC
->SCp
.Status
& not_issued
)) {
1587 Scsi_Cmnd
*ptr
= DONE_SC
;
1590 DPRINTK(debug_eh
, ERR_LEAD
"requesting sense\n", CMDINFO(ptr
));
1593 ptr
->cmnd
[0] = REQUEST_SENSE
;
1597 ptr
->cmnd
[4] = sizeof(ptr
->sense_buffer
);
1601 ptr
->request_buffer
= ptr
->sense_buffer
;
1602 ptr
->request_bufflen
= sizeof(ptr
->sense_buffer
);
1605 aha152x_internal_queue(ptr
, NULL
, check_condition
, ptr
->scsi_done
);
1609 DPRINTK(debug_eh
, ERR_LEAD
"command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC
));
1614 if(DONE_SC
&& DONE_SC
->scsi_done
) {
1615 #if defined(AHA152X_DEBUG)
1616 int hostno
=DONE_SC
->device
->host
->host_no
;
1617 int id
=DONE_SC
->device
->id
& 0xf;
1618 int lun
=DONE_SC
->device
->lun
& 0x7;
1620 Scsi_Cmnd
*ptr
= DONE_SC
;
1623 /* turn led off, when no commands are in the driver */
1624 HOSTDATA(shpnt
)->commands
--;
1625 if (!HOSTDATA(shpnt
)->commands
)
1626 SETPORT(PORTA
, 0); /* turn led off */
1628 if(ptr
->scsi_done
!= reset_done
) {
1629 kfree(ptr
->host_scribble
);
1630 ptr
->host_scribble
=NULL
;
1634 DPRINTK(debug_done
, DEBUG_LEAD
"calling scsi_done(%p)\n", hostno
, id
, lun
, ptr
);
1635 ptr
->scsi_done(ptr
);
1636 DPRINTK(debug_done
, DEBUG_LEAD
"scsi_done(%p) returned\n", hostno
, id
, lun
, ptr
);
1641 #if defined(AHA152X_STAT)
1643 HOSTDATA(shpnt
)->busfree_without_done_command
++;
1648 CURRENT_SC
= remove_first_SC(&ISSUE_SC
);
1653 #if defined(AHA152X_STAT)
1656 CURRENT_SC
->SCp
.phase
|= selecting
;
1658 DPRINTK(debug_selection
, DEBUG_LEAD
"selecting target\n", CMDINFO(CURRENT_SC
));
1660 /* clear selection timeout */
1661 SETPORT(SSTAT1
, SELTO
);
1663 SETPORT(SCSIID
, (shpnt
->this_id
<< OID_
) | CURRENT_SC
->device
->id
);
1664 SETPORT(SXFRCTL1
, (PARITY
? ENSPCHK
: 0 ) | ENSTIMER
);
1665 SETPORT(SCSISEQ
, ENSELO
| ENAUTOATNO
| (DISCONNECTED_SC
? ENRESELI
: 0));
1667 #if defined(AHA152X_STAT)
1668 HOSTDATA(shpnt
)->busfree_without_new_command
++;
1670 SETPORT(SCSISEQ
, DISCONNECTED_SC
? ENRESELI
: 0);
1673 #if defined(AHA152X_STAT)
1675 HOSTDATA(shpnt
)->busfree_without_any_action
++;
1680 * Selection done (OUT)
1681 * - queue IDENTIFY message and SDTR to selected target for message out
1682 * (ATN asserted automagically via ENAUTOATNO in busfree())
1684 static void seldo_run(struct Scsi_Host
*shpnt
)
1686 SETPORT(SCSISIG
, 0);
1687 SETPORT(SSTAT1
, CLRBUSFREE
);
1688 SETPORT(SSTAT1
, CLRPHASECHG
);
1690 CURRENT_SC
->SCp
.phase
&= ~(selecting
|not_issued
);
1692 SETPORT(SCSISEQ
, 0);
1694 if (TESTLO(SSTAT0
, SELDO
)) {
1695 printk(ERR_LEAD
"aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC
));
1696 done(shpnt
, DID_NO_CONNECT
<< 16);
1700 SETPORT(SSTAT0
, CLRSELDO
);
1702 ADDMSGO(IDENTIFY(RECONNECT
, CURRENT_SC
->device
->lun
));
1704 if (CURRENT_SC
->SCp
.phase
& aborting
) {
1706 } else if (CURRENT_SC
->SCp
.phase
& resetting
) {
1707 ADDMSGO(BUS_DEVICE_RESET
);
1708 } else if (SYNCNEG
==0 && SYNCHRONOUS
) {
1709 CURRENT_SC
->SCp
.phase
|= syncneg
;
1710 ADDMSGO(EXTENDED_MESSAGE
);
1712 ADDMSGO(EXTENDED_SDTR
);
1713 ADDMSGO(50); /* 200ns */
1714 ADDMSGO(8); /* 8 byte req/ack offset */
1716 SYNCNEG
=1; /* negotiation in progress */
1724 * - return command to mid-level with failure cause
1727 static void selto_run(struct Scsi_Host
*shpnt
)
1729 SETPORT(SCSISEQ
, 0);
1730 SETPORT(SSTAT1
, CLRSELTIMO
);
1732 DPRINTK(debug_selection
, DEBUG_LEAD
"selection timeout\n", CMDINFO(CURRENT_SC
));
1735 DPRINTK(debug_selection
, DEBUG_LEAD
"!CURRENT_SC\n", CMDINFO(CURRENT_SC
));
1739 CURRENT_SC
->SCp
.phase
&= ~selecting
;
1741 if (CURRENT_SC
->SCp
.phase
& aborted
) {
1742 DPRINTK(debug_selection
, DEBUG_LEAD
"aborted\n", CMDINFO(CURRENT_SC
));
1743 done(shpnt
, DID_ABORT
<< 16);
1744 } else if (TESTLO(SSTAT0
, SELINGO
)) {
1745 DPRINTK(debug_selection
, DEBUG_LEAD
"arbitration not won\n", CMDINFO(CURRENT_SC
));
1746 done(shpnt
, DID_BUS_BUSY
<< 16);
1748 /* ARBITRATION won, but SELECTION failed */
1749 DPRINTK(debug_selection
, DEBUG_LEAD
"selection failed\n", CMDINFO(CURRENT_SC
));
1750 done(shpnt
, DID_NO_CONNECT
<< 16);
1756 * - put current command back to issue queue
1757 * (reconnection of a disconnected nexus instead
1758 * of successful selection out)
1761 static void seldi_run(struct Scsi_Host
*shpnt
)
1765 unsigned long flags
;
1767 SETPORT(SCSISIG
, 0);
1768 SETPORT(SSTAT0
, CLRSELDI
);
1769 SETPORT(SSTAT1
, CLRBUSFREE
);
1770 SETPORT(SSTAT1
, CLRPHASECHG
);
1773 if(!(CURRENT_SC
->SCp
.phase
& not_issued
))
1774 printk(ERR_LEAD
"command should not have been issued yet\n", CMDINFO(CURRENT_SC
));
1776 DPRINTK(debug_selection
, ERR_LEAD
"command requeued - reselection\n", CMDINFO(CURRENT_SC
));
1779 append_SC(&ISSUE_SC
, CURRENT_SC
);
1785 if(!DISCONNECTED_SC
) {
1786 DPRINTK(debug_selection
, DEBUG_LEAD
"unexpected SELDI ", CMDINFO(CURRENT_SC
));
1792 selid
= GETPORT(SELID
) & ~(1 << shpnt
->this_id
);
1795 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO
, selid
);
1799 for(target
=7; !(selid
& (1 << target
)); target
--)
1802 if(selid
& ~(1 << target
)) {
1803 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1808 SETPORT(SCSIID
, (shpnt
->this_id
<< OID_
) | target
);
1809 SETPORT(SCSISEQ
, 0);
1811 SETRATE(HOSTDATA(shpnt
)->syncrate
[target
]);
1813 RECONN_TARGET
=target
;
1814 DPRINTK(debug_selection
, DEBUG_LEAD
"target %d reselected (%02x).\n", CMDINFO(CURRENT_SC
), target
, selid
);
1819 * - handle initial message after reconnection to identify
1820 * reconnecting nexus
1821 * - queue command on DISCONNECTED_SC on DISCONNECT message
1822 * - set completed flag on COMMAND COMPLETE
1823 * (other completition code moved to busfree_run)
1824 * - handle response to SDTR
1825 * - clear synchronous transfer agreements on BUS RESET
1827 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1830 static void msgi_run(struct Scsi_Host
*shpnt
)
1833 int sstat1
= GETPORT(SSTAT1
);
1835 if(sstat1
& (PHASECHG
|PHASEMIS
|BUSFREE
) || !(sstat1
& REQINIT
))
1838 if(TESTLO(SSTAT0
,SPIORDY
)) {
1839 DPRINTK(debug_msgi
, DEBUG_LEAD
"!SPIORDY\n", CMDINFO(CURRENT_SC
));
1843 ADDMSGI(GETPORT(SCSIDAT
));
1845 #if defined(AHA152X_DEBUG)
1846 if (HOSTDATA(shpnt
)->debug
& debug_msgi
) {
1847 printk(INFO_LEAD
"inbound message %02x ", CMDINFO(CURRENT_SC
), MSGI(0));
1848 scsi_print_msg(&MSGI(0));
1854 if(LASTSTATE
!=seldi
) {
1855 printk(KERN_ERR
"aha152x%d: message in w/o current command not after reselection\n", HOSTNO
);
1859 * Handle reselection
1861 if(!(MSGI(0) & IDENTIFY_BASE
)) {
1862 printk(KERN_ERR
"aha152x%d: target didn't identify after reselection\n", HOSTNO
);
1866 CURRENT_SC
= remove_lun_SC(&DISCONNECTED_SC
, RECONN_TARGET
, MSGI(0) & 0x3f);
1870 printk(KERN_ERR
"aha152x%d: no disconnected command for target %d/%d\n", HOSTNO
, RECONN_TARGET
, MSGI(0) & 0x3f);
1874 DPRINTK(debug_msgi
, DEBUG_LEAD
"target reconnected\n", CMDINFO(CURRENT_SC
));
1876 CURRENT_SC
->SCp
.Message
= MSGI(0);
1877 CURRENT_SC
->SCp
.phase
&= ~disconnected
;
1881 /* next message if any */
1885 CURRENT_SC
->SCp
.Message
= MSGI(0);
1890 printk(WARN_LEAD
"target was not allowed to disconnect\n", CMDINFO(CURRENT_SC
));
1892 CURRENT_SC
->SCp
.phase
|= disconnected
;
1895 case COMMAND_COMPLETE
:
1896 if(CURRENT_SC
->SCp
.phase
& completed
)
1897 DPRINTK(debug_msgi
, DEBUG_LEAD
"again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC
));
1899 CURRENT_SC
->SCp
.phase
|= completed
;
1902 case MESSAGE_REJECT
:
1904 printk(INFO_LEAD
"Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC
));
1905 SYNCNEG
=2; /* negotiation completed */
1907 printk(INFO_LEAD
"inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC
));
1913 case RESTORE_POINTERS
:
1916 case EXTENDED_MESSAGE
:
1917 if(MSGILEN
<2 || MSGILEN
<MSGI(1)+2) {
1918 /* not yet completed */
1928 printk(ERR_LEAD
"SDTR message length!=3\n", CMDINFO(CURRENT_SC
));
1932 if (!HOSTDATA(shpnt
)->synchronous
)
1935 printk(INFO_LEAD
, CMDINFO(CURRENT_SC
));
1936 scsi_print_msg(&MSGI(0));
1939 ticks
= (MSGI(3) * 4 + 49) / 50;
1942 /* negotiation in progress */
1943 if (ticks
> 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1944 ADDMSGO(MESSAGE_REJECT
);
1945 printk(INFO_LEAD
"received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC
));
1949 SYNCRATE
|= ((ticks
- 2) << 4) + MSGI(4);
1950 } else if (ticks
<= 9 && MSGI(4) >= 1) {
1951 ADDMSGO(EXTENDED_MESSAGE
);
1953 ADDMSGO(EXTENDED_SDTR
);
1965 SYNCRATE
|= ((ticks
- 2) << 4) + MSGI(4);
1967 /* requested SDTR is too slow, do it asynchronously */
1968 printk(INFO_LEAD
"Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC
));
1969 ADDMSGO(MESSAGE_REJECT
);
1972 SYNCNEG
=2; /* negotiation completed */
1977 case BUS_DEVICE_RESET
:
1981 for(i
=0; i
<8; i
++) {
1982 HOSTDATA(shpnt
)->syncrate
[i
]=0;
1983 HOSTDATA(shpnt
)->syncneg
[i
]=0;
1989 case EXTENDED_MODIFY_DATA_POINTER
:
1990 case EXTENDED_EXTENDED_IDENTIFY
:
1993 ADDMSGO(MESSAGE_REJECT
);
2003 static void msgi_end(struct Scsi_Host
*shpnt
)
2006 printk(WARN_LEAD
"target left before message completed (%d)\n", CMDINFO(CURRENT_SC
), MSGILEN
);
2008 if (MSGOLEN
> 0 && !(GETPORT(SSTAT1
) & BUSFREE
)) {
2009 DPRINTK(debug_msgi
, DEBUG_LEAD
"msgo pending\n", CMDINFO(CURRENT_SC
));
2010 SETPORT(SCSISIG
, P_MSGI
| SIG_ATNO
);
2018 static void msgo_init(struct Scsi_Host
*shpnt
)
2021 if((CURRENT_SC
->SCp
.phase
& syncneg
) && SYNCNEG
==2 && SYNCRATE
==0) {
2022 ADDMSGO(IDENTIFY(RECONNECT
, CURRENT_SC
->device
->lun
));
2024 printk(INFO_LEAD
"unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC
));
2025 ADDMSGO(MESSAGE_REJECT
);
2029 #if defined(AHA152X_DEBUG)
2030 if(HOSTDATA(shpnt
)->debug
& debug_msgo
) {
2033 printk(DEBUG_LEAD
"messages( ", CMDINFO(CURRENT_SC
));
2034 for (i
=0; i
<MSGOLEN
; i
+=scsi_print_msg(&MSGO(i
)), printk(" "))
2045 static void msgo_run(struct Scsi_Host
*shpnt
)
2048 DPRINTK(debug_msgo
, DEBUG_LEAD
"messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC
), MSGO_I
, MSGOLEN
);
2050 while(MSGO_I
<MSGOLEN
) {
2051 DPRINTK(debug_msgo
, DEBUG_LEAD
"message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC
), MSGO(MSGO_I
), MSGO_I
, MSGOLEN
);
2053 if(TESTLO(SSTAT0
, SPIORDY
)) {
2054 DPRINTK(debug_msgo
, DEBUG_LEAD
"!SPIORDY\n", CMDINFO(CURRENT_SC
));
2058 if (MSGO_I
==MSGOLEN
-1) {
2059 /* Leave MESSAGE OUT after transfer */
2060 SETPORT(SSTAT1
, CLRATNO
);
2064 if (MSGO(MSGO_I
) & IDENTIFY_BASE
)
2065 CURRENT_SC
->SCp
.phase
|= identified
;
2067 if (MSGO(MSGO_I
)==ABORT
)
2068 CURRENT_SC
->SCp
.phase
|= aborted
;
2070 if (MSGO(MSGO_I
)==BUS_DEVICE_RESET
)
2071 CURRENT_SC
->SCp
.phase
|= resetted
;
2073 SETPORT(SCSIDAT
, MSGO(MSGO_I
++));
2077 static void msgo_end(struct Scsi_Host
*shpnt
)
2079 if(MSGO_I
<MSGOLEN
) {
2080 printk(ERR_LEAD
"message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC
), MSGO_I
, MSGOLEN
);
2082 printk(INFO_LEAD
"Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC
));
2095 static void cmd_init(struct Scsi_Host
*shpnt
)
2097 if (CURRENT_SC
->SCp
.sent_command
) {
2098 printk(ERR_LEAD
"command already sent\n", CMDINFO(CURRENT_SC
));
2099 done(shpnt
, DID_ERROR
<< 16);
2103 #if defined(AHA152X_DEBUG)
2104 if (HOSTDATA(shpnt
)->debug
& debug_cmd
) {
2105 printk(DEBUG_LEAD
"cmd_init: ", CMDINFO(CURRENT_SC
));
2106 __scsi_print_command(CURRENT_SC
->cmnd
);
2117 static void cmd_run(struct Scsi_Host
*shpnt
)
2119 if(CMD_I
==CURRENT_SC
->cmd_len
) {
2120 DPRINTK(debug_cmd
, DEBUG_LEAD
"command already completely sent (%d/%d)", CMDINFO(CURRENT_SC
), CMD_I
, CURRENT_SC
->cmd_len
);
2124 while(CMD_I
<CURRENT_SC
->cmd_len
) {
2125 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
);
2127 if(TESTLO(SSTAT0
, SPIORDY
)) {
2128 DPRINTK(debug_cmd
, DEBUG_LEAD
"!SPIORDY\n", CMDINFO(CURRENT_SC
));
2132 SETPORT(SCSIDAT
, CURRENT_SC
->cmnd
[CMD_I
++]);
2136 static void cmd_end(struct Scsi_Host
*shpnt
)
2138 if(CMD_I
<CURRENT_SC
->cmd_len
)
2139 printk(ERR_LEAD
"command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC
), CMD_I
, CURRENT_SC
->cmd_len
);
2141 CURRENT_SC
->SCp
.sent_command
++;
2148 static void status_run(struct Scsi_Host
*shpnt
)
2150 if(TESTLO(SSTAT0
,SPIORDY
)) {
2151 DPRINTK(debug_status
, DEBUG_LEAD
"!SPIORDY\n", CMDINFO(CURRENT_SC
));
2155 CURRENT_SC
->SCp
.Status
= GETPORT(SCSIDAT
);
2157 #if defined(AHA152X_DEBUG)
2158 if (HOSTDATA(shpnt
)->debug
& debug_status
) {
2159 printk(DEBUG_LEAD
"inbound status %02x ", CMDINFO(CURRENT_SC
), CURRENT_SC
->SCp
.Status
);
2160 scsi_print_status(CURRENT_SC
->SCp
.Status
);
2170 static void datai_init(struct Scsi_Host
*shpnt
)
2172 SETPORT(DMACNTRL0
, RSTFIFO
);
2173 SETPORT(DMACNTRL0
, RSTFIFO
|ENDMA
);
2175 SETPORT(SXFRCTL0
, CH1
|CLRSTCNT
);
2176 SETPORT(SXFRCTL0
, CH1
|SCSIEN
|DMAEN
);
2178 SETPORT(SIMODE0
, 0);
2179 SETPORT(SIMODE1
, ENSCSIPERR
| ENSCSIRST
| ENPHASEMIS
| ENBUSFREE
);
2182 DPRINTK(debug_datai
,
2183 DEBUG_LEAD
"datai_init: request_bufflen=%d resid=%d\n",
2184 CMDINFO(CURRENT_SC
), CURRENT_SC
->request_bufflen
, CURRENT_SC
->resid
);
2187 static void datai_run(struct Scsi_Host
*shpnt
)
2189 unsigned long the_time
;
2190 int fifodata
, data_count
;
2193 * loop while the phase persists or the fifos are not empty
2196 while(TESTLO(DMASTAT
, INTSTAT
) || TESTLO(DMASTAT
, DFIFOEMP
) || TESTLO(SSTAT2
, SEMPTY
)) {
2197 /* FIXME: maybe this should be done by setting up
2198 * STCNT to trigger ENSWRAP interrupt, instead of
2199 * polling for DFIFOFULL
2201 the_time
=jiffies
+ 100*HZ
;
2202 while(TESTLO(DMASTAT
, DFIFOFULL
|INTSTAT
) && time_before(jiffies
,the_time
))
2205 if(TESTLO(DMASTAT
, DFIFOFULL
|INTSTAT
)) {
2206 printk(ERR_LEAD
"datai timeout", CMDINFO(CURRENT_SC
));
2211 if(TESTHI(DMASTAT
, DFIFOFULL
)) {
2214 the_time
=jiffies
+ 100*HZ
;
2215 while(TESTLO(SSTAT2
, SEMPTY
) && time_before(jiffies
,the_time
))
2218 if(TESTLO(SSTAT2
, SEMPTY
)) {
2219 printk(ERR_LEAD
"datai sempty timeout", CMDINFO(CURRENT_SC
));
2224 fifodata
= GETPORT(FIFOSTAT
);
2227 if(CURRENT_SC
->SCp
.this_residual
>0) {
2228 while(fifodata
>0 && CURRENT_SC
->SCp
.this_residual
>0) {
2229 data_count
= fifodata
>CURRENT_SC
->SCp
.this_residual
?
2230 CURRENT_SC
->SCp
.this_residual
:
2232 fifodata
-= data_count
;
2234 if(data_count
& 1) {
2235 DPRINTK(debug_datai
, DEBUG_LEAD
"8bit\n", CMDINFO(CURRENT_SC
));
2236 SETPORT(DMACNTRL0
, ENDMA
|_8BIT
);
2237 *CURRENT_SC
->SCp
.ptr
++ = GETPORT(DATAPORT
);
2238 CURRENT_SC
->SCp
.this_residual
--;
2240 SETPORT(DMACNTRL0
, ENDMA
);
2243 if(data_count
> 1) {
2244 DPRINTK(debug_datai
, DEBUG_LEAD
"16bit(%d)\n", CMDINFO(CURRENT_SC
), data_count
);
2246 insw(DATAPORT
, CURRENT_SC
->SCp
.ptr
, data_count
);
2247 CURRENT_SC
->SCp
.ptr
+= 2 * data_count
;
2248 CURRENT_SC
->SCp
.this_residual
-= 2 * data_count
;
2249 DATA_LEN
+= 2 * data_count
;
2252 if(CURRENT_SC
->SCp
.this_residual
==0 && CURRENT_SC
->SCp
.buffers_residual
>0) {
2253 /* advance to next buffer */
2254 CURRENT_SC
->SCp
.buffers_residual
--;
2255 CURRENT_SC
->SCp
.buffer
++;
2256 CURRENT_SC
->SCp
.ptr
= SG_ADDRESS(CURRENT_SC
->SCp
.buffer
);
2257 CURRENT_SC
->SCp
.this_residual
= CURRENT_SC
->SCp
.buffer
->length
;
2260 } else if(fifodata
>0) {
2261 printk(ERR_LEAD
"no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC
), fifodata
, GETPORT(FIFOSTAT
));
2262 SETPORT(DMACNTRL0
, ENDMA
|_8BIT
);
2265 data
=GETPORT(DATAPORT
);
2266 DPRINTK(debug_datai
, DEBUG_LEAD
"data=%02x\n", CMDINFO(CURRENT_SC
), data
);
2270 SETPORT(DMACNTRL0
, ENDMA
|_8BIT
);
2274 if(TESTLO(DMASTAT
, INTSTAT
) ||
2275 TESTLO(DMASTAT
, DFIFOEMP
) ||
2276 TESTLO(SSTAT2
, SEMPTY
) ||
2277 GETPORT(FIFOSTAT
)>0) {
2279 * something went wrong, if there's something left in the fifos
2280 * or the phase didn't change
2282 printk(ERR_LEAD
"fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC
));
2286 if(DATA_LEN
!=GETSTCNT()) {
2288 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2289 CMDINFO(CURRENT_SC
), DATA_LEN
, GETSTCNT(), GETSTCNT()-DATA_LEN
, GETPORT(FIFOSTAT
));
2295 static void datai_end(struct Scsi_Host
*shpnt
)
2297 CURRENT_SC
->resid
-= GETSTCNT();
2299 DPRINTK(debug_datai
,
2300 DEBUG_LEAD
"datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2301 CMDINFO(CURRENT_SC
), CURRENT_SC
->request_bufflen
, CURRENT_SC
->resid
, GETSTCNT());
2303 SETPORT(SXFRCTL0
, CH1
|CLRSTCNT
);
2304 SETPORT(DMACNTRL0
, 0);
2311 static void datao_init(struct Scsi_Host
*shpnt
)
2313 SETPORT(DMACNTRL0
, WRITE_READ
| RSTFIFO
);
2314 SETPORT(DMACNTRL0
, WRITE_READ
| ENDMA
);
2316 SETPORT(SXFRCTL0
, CH1
|CLRSTCNT
);
2317 SETPORT(SXFRCTL0
, CH1
|SCSIEN
|DMAEN
);
2319 SETPORT(SIMODE0
, 0);
2320 SETPORT(SIMODE1
, ENSCSIPERR
| ENSCSIRST
| ENPHASEMIS
| ENBUSFREE
);
2322 DATA_LEN
= CURRENT_SC
->resid
;
2324 DPRINTK(debug_datao
,
2325 DEBUG_LEAD
"datao_init: request_bufflen=%d; resid=%d\n",
2326 CMDINFO(CURRENT_SC
), CURRENT_SC
->request_bufflen
, CURRENT_SC
->resid
);
2329 static void datao_run(struct Scsi_Host
*shpnt
)
2331 unsigned long the_time
;
2334 /* until phase changes or all data sent */
2335 while(TESTLO(DMASTAT
, INTSTAT
) && CURRENT_SC
->SCp
.this_residual
>0) {
2337 if(data_count
> CURRENT_SC
->SCp
.this_residual
)
2338 data_count
=CURRENT_SC
->SCp
.this_residual
;
2340 if(TESTLO(DMASTAT
, DFIFOEMP
)) {
2341 printk(ERR_LEAD
"datao fifo not empty (%d)", CMDINFO(CURRENT_SC
), GETPORT(FIFOSTAT
));
2346 if(data_count
& 1) {
2347 SETPORT(DMACNTRL0
,WRITE_READ
|ENDMA
|_8BIT
);
2348 SETPORT(DATAPORT
, *CURRENT_SC
->SCp
.ptr
++);
2349 CURRENT_SC
->SCp
.this_residual
--;
2350 CURRENT_SC
->resid
--;
2351 SETPORT(DMACNTRL0
,WRITE_READ
|ENDMA
);
2354 if(data_count
> 1) {
2356 outsw(DATAPORT
, CURRENT_SC
->SCp
.ptr
, data_count
);
2357 CURRENT_SC
->SCp
.ptr
+= 2 * data_count
;
2358 CURRENT_SC
->SCp
.this_residual
-= 2 * data_count
;
2359 CURRENT_SC
->resid
-= 2 * data_count
;
2362 if(CURRENT_SC
->SCp
.this_residual
==0 && CURRENT_SC
->SCp
.buffers_residual
>0) {
2363 /* advance to next buffer */
2364 CURRENT_SC
->SCp
.buffers_residual
--;
2365 CURRENT_SC
->SCp
.buffer
++;
2366 CURRENT_SC
->SCp
.ptr
= SG_ADDRESS(CURRENT_SC
->SCp
.buffer
);
2367 CURRENT_SC
->SCp
.this_residual
= CURRENT_SC
->SCp
.buffer
->length
;
2370 the_time
=jiffies
+ 100*HZ
;
2371 while(TESTLO(DMASTAT
, DFIFOEMP
|INTSTAT
) && time_before(jiffies
,the_time
))
2374 if(TESTLO(DMASTAT
, DFIFOEMP
|INTSTAT
)) {
2375 printk(ERR_LEAD
"dataout timeout", CMDINFO(CURRENT_SC
));
2382 static void datao_end(struct Scsi_Host
*shpnt
)
2384 if(TESTLO(DMASTAT
, DFIFOEMP
)) {
2385 int data_count
= (DATA_LEN
- CURRENT_SC
->resid
) - GETSTCNT();
2387 DPRINTK(debug_datao
, DEBUG_LEAD
"datao: %d bytes to resend (%d written, %d transferred)\n",
2388 CMDINFO(CURRENT_SC
),
2390 DATA_LEN
-CURRENT_SC
->resid
,
2393 CURRENT_SC
->resid
+= data_count
;
2395 if(CURRENT_SC
->use_sg
) {
2396 data_count
-= CURRENT_SC
->SCp
.ptr
- SG_ADDRESS(CURRENT_SC
->SCp
.buffer
);
2397 while(data_count
>0) {
2398 CURRENT_SC
->SCp
.buffer
--;
2399 CURRENT_SC
->SCp
.buffers_residual
++;
2400 data_count
-= CURRENT_SC
->SCp
.buffer
->length
;
2402 CURRENT_SC
->SCp
.ptr
= SG_ADDRESS(CURRENT_SC
->SCp
.buffer
) - data_count
;
2403 CURRENT_SC
->SCp
.this_residual
= CURRENT_SC
->SCp
.buffer
->length
+ data_count
;
2405 CURRENT_SC
->SCp
.ptr
-= data_count
;
2406 CURRENT_SC
->SCp
.this_residual
+= data_count
;
2410 DPRINTK(debug_datao
, DEBUG_LEAD
"datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2411 CMDINFO(CURRENT_SC
),
2412 CURRENT_SC
->request_bufflen
,
2416 SETPORT(SXFRCTL0
, CH1
|CLRCH1
|CLRSTCNT
);
2417 SETPORT(SXFRCTL0
, CH1
);
2419 SETPORT(DMACNTRL0
, 0);
2423 * figure out what state we're in
2426 static int update_state(struct Scsi_Host
*shpnt
)
2429 unsigned int stat0
= GETPORT(SSTAT0
);
2430 unsigned int stat1
= GETPORT(SSTAT1
);
2435 if(stat1
& SCSIRSTI
) {
2438 SETPORT(SSTAT1
,SCSIRSTI
);
2439 } else if(stat0
& SELDI
&& PREVSTATE
==busfree
) {
2441 } else if(stat0
& SELDO
&& CURRENT_SC
&& (CURRENT_SC
->SCp
.phase
& selecting
)) {
2443 } else if(stat1
& SELTO
) {
2445 } else if(stat1
& BUSFREE
) {
2447 SETPORT(SSTAT1
,BUSFREE
);
2448 } else if(stat1
& SCSIPERR
) {
2450 SETPORT(SSTAT1
,SCSIPERR
);
2451 } else if(stat1
& REQINIT
) {
2452 switch(GETPORT(SCSISIG
) & P_MASK
) {
2453 case P_MSGI
: STATE
=msgi
; break;
2454 case P_MSGO
: STATE
=msgo
; break;
2455 case P_DATAO
: STATE
=datao
; break;
2456 case P_DATAI
: STATE
=datai
; break;
2457 case P_STATUS
: STATE
=status
; break;
2458 case P_CMD
: STATE
=cmd
; break;
2463 if((stat0
& SELDI
) && STATE
!=seldi
&& !dataphase
) {
2464 printk(INFO_LEAD
"reselection missed?", CMDINFO(CURRENT_SC
));
2468 if(STATE
!=PREVSTATE
) {
2469 LASTSTATE
=PREVSTATE
;
2476 * handle parity error
2478 * FIXME: in which phase?
2481 static void parerr_run(struct Scsi_Host
*shpnt
)
2483 printk(ERR_LEAD
"parity error\n", CMDINFO(CURRENT_SC
));
2484 done(shpnt
, DID_PARITY
<< 16);
2491 static void rsti_run(struct Scsi_Host
*shpnt
)
2495 printk(KERN_NOTICE
"aha152x%d: scsi reset in\n", HOSTNO
);
2497 ptr
=DISCONNECTED_SC
;
2499 Scsi_Cmnd
*next
= SCNEXT(ptr
);
2501 if (!ptr
->device
->soft_reset
) {
2502 remove_SC(&DISCONNECTED_SC
, ptr
);
2504 kfree(ptr
->host_scribble
);
2505 ptr
->host_scribble
=NULL
;
2507 ptr
->result
= DID_RESET
<< 16;
2508 ptr
->scsi_done(ptr
);
2514 if(CURRENT_SC
&& !CURRENT_SC
->device
->soft_reset
)
2515 done(shpnt
, DID_RESET
<< 16 );
2520 * bottom-half handler
2523 static void is_complete(struct Scsi_Host
*shpnt
)
2526 unsigned long flags
;
2530 if(HOSTDATA(shpnt
)->in_intr
) {
2532 /* aha152x_error never returns.. */
2533 aha152x_error(shpnt
, "bottom-half already running!?");
2535 HOSTDATA(shpnt
)->in_intr
++;
2538 * loop while there are interrupt conditions pending
2542 unsigned long start
= jiffies
;
2545 dataphase
=update_state(shpnt
);
2547 DPRINTK(debug_phases
, LEAD
"start %s %s(%s)\n", CMDINFO(CURRENT_SC
), states
[STATE
].name
, states
[PREVSTATE
].name
, states
[LASTSTATE
].name
);
2550 * end previous state
2553 if(PREVSTATE
!=STATE
&& states
[PREVSTATE
].end
)
2554 states
[PREVSTATE
].end(shpnt
);
2557 * disable SPIO mode if previous phase used it
2558 * and this one doesn't
2561 if(states
[PREVSTATE
].spio
&& !states
[STATE
].spio
) {
2562 SETPORT(SXFRCTL0
, CH1
);
2563 SETPORT(DMACNTRL0
, 0);
2565 CURRENT_SC
->SCp
.phase
&= ~spiordy
;
2569 * accept current dataphase phase
2573 SETPORT(SSTAT0
, REQINIT
);
2574 SETPORT(SCSISIG
, GETPORT(SCSISIG
) & P_MASK
);
2575 SETPORT(SSTAT1
, PHASECHG
);
2579 * enable SPIO mode if previous didn't use it
2583 if(!states
[PREVSTATE
].spio
&& states
[STATE
].spio
) {
2584 SETPORT(DMACNTRL0
, 0);
2585 SETPORT(SXFRCTL0
, CH1
|SPIOEN
);
2587 CURRENT_SC
->SCp
.phase
|= spiordy
;
2591 * initialize for new state
2594 if(PREVSTATE
!=STATE
&& states
[STATE
].init
)
2595 states
[STATE
].init(shpnt
);
2598 * handle current state
2601 if(states
[STATE
].run
)
2602 states
[STATE
].run(shpnt
);
2604 printk(ERR_LEAD
"unexpected state (%x)\n", CMDINFO(CURRENT_SC
), STATE
);
2607 * setup controller to interrupt on
2608 * the next expected condition and
2609 * loop if it's already there
2613 pending
=setup_expected_interrupts(shpnt
);
2614 #if defined(AHA152X_STAT)
2615 HOSTDATA(shpnt
)->count
[STATE
]++;
2616 if(PREVSTATE
!=STATE
)
2617 HOSTDATA(shpnt
)->count_trans
[STATE
]++;
2618 HOSTDATA(shpnt
)->time
[STATE
] += jiffies
-start
;
2621 DPRINTK(debug_phases
, LEAD
"end %s %s(%s)\n", CMDINFO(CURRENT_SC
), states
[STATE
].name
, states
[PREVSTATE
].name
, states
[LASTSTATE
].name
);
2625 * enable interrupts and leave bottom-half
2628 HOSTDATA(shpnt
)->in_intr
--;
2629 SETBITS(DMACNTRL0
, INTEN
);
2635 * Dump the current driver status and panic
2637 static void aha152x_error(struct Scsi_Host
*shpnt
, char *msg
)
2639 printk(KERN_EMERG
"\naha152x%d: %s\n", HOSTNO
, msg
);
2641 panic("aha152x panic\n");
2645 * Display registers of AIC-6260
2647 static void disp_ports(struct Scsi_Host
*shpnt
)
2649 #if defined(AHA152X_DEBUG)
2652 printk("\n%s: %s(%s) ",
2653 CURRENT_SC
? "busy" : "waiting",
2655 states
[PREVSTATE
].name
);
2657 s
= GETPORT(SCSISEQ
);
2658 printk("SCSISEQ( ");
2660 printk("TARGET MODE ");
2668 printk("AUTOATNO ");
2670 printk("AUTOATNI ");
2672 printk("AUTOATNP ");
2674 printk("SCSIRSTO ");
2677 printk(" SCSISIG(");
2678 s
= GETPORT(SCSISIG
);
2679 switch (s
& P_MASK
) {
2693 printk("MESSAGE OUT");
2696 printk("MESSAGE IN");
2699 printk("*invalid*");
2705 printk("INTSTAT (%s); ", TESTHI(DMASTAT
, INTSTAT
) ? "hi" : "lo");
2708 s
= GETPORT(SSTAT0
);
2726 s
= GETPORT(SSTAT1
);
2732 printk("SCSIRSTI ");
2734 printk("PHASEMIS ");
2738 printk("SCSIPERR ");
2740 printk("PHASECHG ");
2748 s
= GETPORT(SSTAT0
) & GETPORT(SIMODE0
);
2767 s
= GETPORT(SSTAT1
) & GETPORT(SIMODE1
);
2774 printk("SCSIRSTI ");
2776 printk("PHASEMIS ");
2780 printk("SCSIPERR ");
2782 printk("PHASECHG ");
2787 printk("SXFRCTL0( ");
2789 s
= GETPORT(SXFRCTL0
);
2797 printk("CLRSTCNT ");
2806 s
= GETPORT(SCSISIG
);
2819 printk("SELID (%02x), ", GETPORT(SELID
));
2821 printk("STCNT (%d), ", GETSTCNT());
2825 s
= GETPORT(SSTAT2
);
2832 printk("); SFCNT (%d); ", s
& (SFULL
| SFCNT
));
2834 s
= GETPORT(SSTAT3
);
2835 printk("SCSICNT (%d), OFFCNT(%d), ", (s
& 0xf0) >> 4, s
& 0x0f);
2838 s
= GETPORT(SSTAT4
);
2847 printk("DMACNTRL0( ");
2848 s
= GETPORT(DMACNTRL0
);
2849 printk("%s ", s
& _8BIT
? "8BIT" : "16BIT");
2850 printk("%s ", s
& DMA
? "DMA" : "PIO");
2851 printk("%s ", s
& WRITE_READ
? "WRITE" : "READ");
2862 printk("DMASTAT( ");
2863 s
= GETPORT(DMASTAT
);
2869 printk("DFIFOFULL ");
2871 printk("DFIFOEMP ");
2877 * display enabled interrupts
2879 static void disp_enintr(struct Scsi_Host
*shpnt
)
2883 printk(KERN_DEBUG
"enabled interrupts ( ");
2885 s
= GETPORT(SIMODE0
);
2891 printk("ENSELINGO ");
2897 printk("ENSPIORDY ");
2899 printk("ENDMADONE ");
2901 s
= GETPORT(SIMODE1
);
2903 printk("ENSELTIMO ");
2905 printk("ENATNTARG ");
2907 printk("ENPHASEMIS ");
2909 printk("ENBUSFREE ");
2911 printk("ENSCSIPERR ");
2913 printk("ENPHASECHG ");
2915 printk("ENREQINIT ");
2920 * Show the command data of a command
2922 static void show_command(Scsi_Cmnd
*ptr
)
2924 scmd_printk(KERN_DEBUG
, ptr
, "%p: cmnd=(", ptr
);
2926 __scsi_print_command(ptr
->cmnd
);
2928 printk(KERN_DEBUG
"); request_bufflen=%d; resid=%d; phase |",
2929 ptr
->request_bufflen
, ptr
->resid
);
2931 if (ptr
->SCp
.phase
& not_issued
)
2932 printk("not issued|");
2933 if (ptr
->SCp
.phase
& selecting
)
2934 printk("selecting|");
2935 if (ptr
->SCp
.phase
& identified
)
2936 printk("identified|");
2937 if (ptr
->SCp
.phase
& disconnected
)
2938 printk("disconnected|");
2939 if (ptr
->SCp
.phase
& completed
)
2940 printk("completed|");
2941 if (ptr
->SCp
.phase
& spiordy
)
2943 if (ptr
->SCp
.phase
& syncneg
)
2945 if (ptr
->SCp
.phase
& aborted
)
2947 if (ptr
->SCp
.phase
& resetted
)
2948 printk("resetted|");
2950 printk("; next=0x%p\n", SCNEXT(ptr
));
2952 printk("; next=(host scribble NULL)\n");
2957 * Dump the queued data
2959 static void show_queues(struct Scsi_Host
*shpnt
)
2962 unsigned long flags
;
2965 printk(KERN_DEBUG
"\nqueue status:\nissue_SC:\n");
2966 for (ptr
= ISSUE_SC
; ptr
; ptr
= SCNEXT(ptr
))
2970 printk(KERN_DEBUG
"current_SC:\n");
2972 show_command(CURRENT_SC
);
2974 printk(KERN_DEBUG
"none\n");
2976 printk(KERN_DEBUG
"disconnected_SC:\n");
2977 for (ptr
= DISCONNECTED_SC
; ptr
; ptr
= SCDATA(ptr
) ? SCNEXT(ptr
) : NULL
)
2985 #define SPRINTF(args...) pos += sprintf(pos, ## args)
2987 static int get_command(char *pos
, Scsi_Cmnd
* ptr
)
2992 SPRINTF("0x%08x: target=%d; lun=%d; cmnd=( ",
2993 (unsigned int) ptr
, ptr
->device
->id
, ptr
->device
->lun
);
2995 for (i
= 0; i
< COMMAND_SIZE(ptr
->cmnd
[0]); i
++)
2996 SPRINTF("0x%02x ", ptr
->cmnd
[i
]);
2998 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
2999 ptr
->resid
, ptr
->SCp
.this_residual
, ptr
->SCp
.buffers_residual
);
3001 if (ptr
->SCp
.phase
& not_issued
)
3002 SPRINTF("not issued|");
3003 if (ptr
->SCp
.phase
& selecting
)
3004 SPRINTF("selecting|");
3005 if (ptr
->SCp
.phase
& disconnected
)
3006 SPRINTF("disconnected|");
3007 if (ptr
->SCp
.phase
& aborted
)
3008 SPRINTF("aborted|");
3009 if (ptr
->SCp
.phase
& identified
)
3010 SPRINTF("identified|");
3011 if (ptr
->SCp
.phase
& completed
)
3012 SPRINTF("completed|");
3013 if (ptr
->SCp
.phase
& spiordy
)
3014 SPRINTF("spiordy|");
3015 if (ptr
->SCp
.phase
& syncneg
)
3016 SPRINTF("syncneg|");
3017 SPRINTF("; next=0x%p\n", SCNEXT(ptr
));
3019 return (pos
- start
);
3022 static int get_ports(struct Scsi_Host
*shpnt
, char *pos
)
3027 SPRINTF("\n%s: %s(%s) ", CURRENT_SC
? "on bus" : "waiting", states
[STATE
].name
, states
[PREVSTATE
].name
);
3029 s
= GETPORT(SCSISEQ
);
3030 SPRINTF("SCSISEQ( ");
3032 SPRINTF("TARGET MODE ");
3040 SPRINTF("AUTOATNO ");
3042 SPRINTF("AUTOATNI ");
3044 SPRINTF("AUTOATNP ");
3046 SPRINTF("SCSIRSTO ");
3049 SPRINTF(" SCSISIG(");
3050 s
= GETPORT(SCSISIG
);
3051 switch (s
& P_MASK
) {
3053 SPRINTF("DATA OUT");
3065 SPRINTF("MESSAGE OUT");
3068 SPRINTF("MESSAGE IN");
3071 SPRINTF("*invalid*");
3077 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT
, INTSTAT
) ? "hi" : "lo");
3080 s
= GETPORT(SSTAT0
);
3088 SPRINTF("SELINGO ");
3094 SPRINTF("SPIORDY ");
3096 SPRINTF("DMADONE ");
3098 s
= GETPORT(SSTAT1
);
3102 SPRINTF("ATNTARG ");
3104 SPRINTF("SCSIRSTI ");
3106 SPRINTF("PHASEMIS ");
3108 SPRINTF("BUSFREE ");
3110 SPRINTF("SCSIPERR ");
3112 SPRINTF("PHASECHG ");
3114 SPRINTF("REQINIT ");
3120 s
= GETPORT(SSTAT0
) & GETPORT(SIMODE0
);
3129 SPRINTF("SELINGO ");
3135 SPRINTF("SPIORDY ");
3137 SPRINTF("DMADONE ");
3139 s
= GETPORT(SSTAT1
) & GETPORT(SIMODE1
);
3144 SPRINTF("ATNTARG ");
3146 SPRINTF("SCSIRSTI ");
3148 SPRINTF("PHASEMIS ");
3150 SPRINTF("BUSFREE ");
3152 SPRINTF("SCSIPERR ");
3154 SPRINTF("PHASECHG ");
3156 SPRINTF("REQINIT ");
3159 SPRINTF("SXFRCTL0( ");
3161 s
= GETPORT(SXFRCTL0
);
3169 SPRINTF("CLRSTCNT ");
3176 SPRINTF("SIGNAL( ");
3178 s
= GETPORT(SCSISIG
);
3191 SPRINTF("SELID(%02x), ", GETPORT(SELID
));
3193 SPRINTF("STCNT(%d), ", GETSTCNT());
3195 SPRINTF("SSTAT2( ");
3197 s
= GETPORT(SSTAT2
);
3199 SPRINTF("SOFFSET ");
3204 SPRINTF("); SFCNT (%d); ", s
& (SFULL
| SFCNT
));
3206 s
= GETPORT(SSTAT3
);
3207 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s
& 0xf0) >> 4, s
& 0x0f);
3209 SPRINTF("SSTAT4( ");
3210 s
= GETPORT(SSTAT4
);
3212 SPRINTF("SYNCERR ");
3219 SPRINTF("DMACNTRL0( ");
3220 s
= GETPORT(DMACNTRL0
);
3221 SPRINTF("%s ", s
& _8BIT
? "8BIT" : "16BIT");
3222 SPRINTF("%s ", s
& DMA
? "DMA" : "PIO");
3223 SPRINTF("%s ", s
& WRITE_READ
? "WRITE" : "READ");
3229 SPRINTF("RSTFIFO ");
3234 SPRINTF("DMASTAT( ");
3235 s
= GETPORT(DMASTAT
);
3239 SPRINTF("WORDRDY ");
3241 SPRINTF("DFIFOFULL ");
3243 SPRINTF("DFIFOEMP ");
3246 SPRINTF("enabled interrupts( ");
3248 s
= GETPORT(SIMODE0
);
3250 SPRINTF("ENSELDO ");
3252 SPRINTF("ENSELDI ");
3254 SPRINTF("ENSELINGO ");
3256 SPRINTF("ENSWRAP ");
3258 SPRINTF("ENSDONE ");
3260 SPRINTF("ENSPIORDY ");
3262 SPRINTF("ENDMADONE ");
3264 s
= GETPORT(SIMODE1
);
3266 SPRINTF("ENSELTIMO ");
3268 SPRINTF("ENATNTARG ");
3270 SPRINTF("ENPHASEMIS ");
3272 SPRINTF("ENBUSFREE ");
3274 SPRINTF("ENSCSIPERR ");
3276 SPRINTF("ENPHASECHG ");
3278 SPRINTF("ENREQINIT ");
3281 return (pos
- start
);
3284 static int aha152x_set_info(char *buffer
, int length
, struct Scsi_Host
*shpnt
)
3286 if(!shpnt
|| !buffer
|| length
<8 || strncmp("aha152x ", buffer
, 8)!=0)
3289 #if defined(AHA152X_DEBUG)
3290 if(length
>14 && strncmp("debug ", buffer
+8, 6)==0) {
3291 int debug
= HOSTDATA(shpnt
)->debug
;
3293 HOSTDATA(shpnt
)->debug
= simple_strtoul(buffer
+14, NULL
, 0);
3295 printk(KERN_INFO
"aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO
, HOSTDATA(shpnt
)->debug
, debug
);
3298 #if defined(AHA152X_STAT)
3299 if(length
>13 && strncmp("reset", buffer
+8, 5)==0) {
3302 HOSTDATA(shpnt
)->total_commands
=0;
3303 HOSTDATA(shpnt
)->disconnections
=0;
3304 HOSTDATA(shpnt
)->busfree_without_any_action
=0;
3305 HOSTDATA(shpnt
)->busfree_without_old_command
=0;
3306 HOSTDATA(shpnt
)->busfree_without_new_command
=0;
3307 HOSTDATA(shpnt
)->busfree_without_done_command
=0;
3308 HOSTDATA(shpnt
)->busfree_with_check_condition
=0;
3309 for (i
= idle
; i
<maxstate
; i
++) {
3310 HOSTDATA(shpnt
)->count
[i
]=0;
3311 HOSTDATA(shpnt
)->count_trans
[i
]=0;
3312 HOSTDATA(shpnt
)->time
[i
]=0;
3315 printk(KERN_INFO
"aha152x%d: stats reseted.\n", HOSTNO
);
3328 #define SPRINTF(args...) \
3329 do { if(pos < buffer + length) pos += sprintf(pos, ## args); } while(0)
3331 static int aha152x_proc_info(struct Scsi_Host
*shpnt
, char *buffer
, char **start
,
3332 off_t offset
, int length
, int inout
)
3337 unsigned long flags
;
3340 DPRINTK(debug_procinfo
,
3341 KERN_DEBUG
"aha152x_proc_info: buffer=%p offset=%ld length=%d hostno=%d inout=%d\n",
3342 buffer
, offset
, length
, shpnt
->host_no
, inout
);
3346 return aha152x_set_info(buffer
, length
, shpnt
);
3348 SPRINTF(AHA152X_REVID
"\n");
3350 SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3351 shpnt
->io_port
, shpnt
->io_port
+ shpnt
->n_io_port
- 1);
3352 SPRINTF("interrupt 0x%02x\n", shpnt
->irq
);
3353 SPRINTF("disconnection/reconnection %s\n",
3354 RECONNECT
? "enabled" : "disabled");
3355 SPRINTF("parity checking %s\n",
3356 PARITY
? "enabled" : "disabled");
3357 SPRINTF("synchronous transfers %s\n",
3358 SYNCHRONOUS
? "enabled" : "disabled");
3359 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt
)->commands
);
3362 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3363 for (i
= 0; i
< 8; i
++)
3364 if (HOSTDATA(shpnt
)->syncrate
[i
] & 0x7f)
3365 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3367 (((HOSTDATA(shpnt
)->syncrate
[i
] & 0x70) >> 4) + 2),
3368 (((HOSTDATA(shpnt
)->syncrate
[i
] & 0x70) >> 4) + 2) * 50,
3369 HOSTDATA(shpnt
)->syncrate
[i
] & 0x0f);
3371 #if defined(AHA152X_DEBUG)
3372 #define PDEBUG(flags,txt) \
3373 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3375 SPRINTF("enabled debugging options: ");
3377 PDEBUG(debug_procinfo
, "procinfo");
3378 PDEBUG(debug_queue
, "queue");
3379 PDEBUG(debug_intr
, "interrupt");
3380 PDEBUG(debug_selection
, "selection");
3381 PDEBUG(debug_msgo
, "message out");
3382 PDEBUG(debug_msgi
, "message in");
3383 PDEBUG(debug_status
, "status");
3384 PDEBUG(debug_cmd
, "command");
3385 PDEBUG(debug_datai
, "data in");
3386 PDEBUG(debug_datao
, "data out");
3387 PDEBUG(debug_eh
, "eh");
3388 PDEBUG(debug_locks
, "locks");
3389 PDEBUG(debug_phases
, "phases");
3394 SPRINTF("\nqueue status:\n");
3397 SPRINTF("not yet issued commands:\n");
3398 for (ptr
= ISSUE_SC
; ptr
; ptr
= SCNEXT(ptr
))
3399 pos
+= get_command(pos
, ptr
);
3401 SPRINTF("no not yet issued commands\n");
3405 SPRINTF("current command:\n");
3406 pos
+= get_command(pos
, CURRENT_SC
);
3408 SPRINTF("no current command\n");
3410 if (DISCONNECTED_SC
) {
3411 SPRINTF("disconnected commands:\n");
3412 for (ptr
= DISCONNECTED_SC
; ptr
; ptr
= SCNEXT(ptr
))
3413 pos
+= get_command(pos
, ptr
);
3415 SPRINTF("no disconnected commands\n");
3417 pos
+= get_ports(shpnt
, pos
);
3419 #if defined(AHA152X_STAT)
3420 SPRINTF("statistics:\n"
3421 "total commands: %d\n"
3422 "disconnections: %d\n"
3423 "busfree with check condition: %d\n"
3424 "busfree without old command: %d\n"
3425 "busfree without new command: %d\n"
3426 "busfree without done command: %d\n"
3427 "busfree without any action: %d\n"
3432 HOSTDATA(shpnt
)->total_commands
,
3433 HOSTDATA(shpnt
)->disconnections
,
3434 HOSTDATA(shpnt
)->busfree_with_check_condition
,
3435 HOSTDATA(shpnt
)->busfree_without_old_command
,
3436 HOSTDATA(shpnt
)->busfree_without_new_command
,
3437 HOSTDATA(shpnt
)->busfree_without_done_command
,
3438 HOSTDATA(shpnt
)->busfree_without_any_action
);
3439 for(i
=0; i
<maxstate
; i
++) {
3440 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3442 HOSTDATA(shpnt
)->count_trans
[i
],
3443 HOSTDATA(shpnt
)->count
[i
],
3444 HOSTDATA(shpnt
)->time
[i
]);
3448 DPRINTK(debug_procinfo
, KERN_DEBUG
"aha152x_proc_info: pos=%p\n", pos
);
3450 thislength
= pos
- (buffer
+ offset
);
3451 DPRINTK(debug_procinfo
, KERN_DEBUG
"aha152x_proc_info: length=%d thislength=%d\n", length
, thislength
);
3454 DPRINTK(debug_procinfo
, KERN_DEBUG
"aha152x_proc_info: output too short\n");
3459 thislength
= thislength
<length
? thislength
: length
;
3461 DPRINTK(debug_procinfo
, KERN_DEBUG
"aha152x_proc_info: return %d\n", thislength
);
3463 *start
= buffer
+ offset
;
3464 return thislength
< length
? thislength
: length
;
3467 static struct scsi_host_template aha152x_driver_template
= {
3468 .module
= THIS_MODULE
,
3469 .name
= AHA152X_REVID
,
3470 .proc_name
= "aha152x",
3471 .proc_info
= aha152x_proc_info
,
3472 .queuecommand
= aha152x_queue
,
3473 .eh_abort_handler
= aha152x_abort
,
3474 .eh_device_reset_handler
= aha152x_device_reset
,
3475 .eh_bus_reset_handler
= aha152x_bus_reset
,
3476 .eh_host_reset_handler
= aha152x_host_reset
,
3477 .bios_param
= aha152x_biosparam
,
3480 .sg_tablesize
= SG_ALL
,
3482 .use_clustering
= DISABLE_CLUSTERING
,
3485 #if !defined(PCMCIA)
3486 static int setup_count
;
3487 static struct aha152x_setup setup
[2];
3489 /* possible i/o addresses for the AIC-6260; default first */
3490 static unsigned short ports
[] = { 0x340, 0x140 };
3492 #if !defined(SKIP_BIOSTEST)
3493 /* possible locations for the Adaptec BIOS; defaults first */
3494 static unsigned int addresses
[] =
3496 0xdc000, /* default first */
3503 0xeb800, /* VTech Platinum SMP */
3507 /* signatures for various AIC-6[23]60 based controllers.
3508 The point in detecting signatures is to avoid useless and maybe
3509 harmful probes on ports. I'm not sure that all listed boards pass
3510 auto-configuration. For those which fail the BIOS signature is
3511 obsolete, because user intervention to supply the configuration is
3512 needed anyway. May be an information whether or not the BIOS supports
3513 extended translation could be also useful here. */
3514 static struct signature
{
3515 unsigned char *signature
;
3520 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3522 { "Adaptec AHA-1520B", 0x000b, 17 },
3523 /* Adaptec 152x rev B */
3524 { "Adaptec AHA-1520B", 0x0026, 17 },
3525 /* Iomega Jaz Jet ISA (AIC6370Q) */
3526 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3527 /* on-board controller */
3528 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3529 /* on-board controller */
3530 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3531 /* on-board controller */
3532 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3533 /* on-board controller */
3534 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3535 /* ScsiPro-Controller */
3536 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3537 /* Gigabyte Local-Bus-SCSI */
3538 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3540 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3541 /* IBM Thinkpad Dock II */
3542 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3543 /* IBM Thinkpad Dock II SCSI */
3544 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3545 /* DTC 3520A ISA SCSI */
3547 #endif /* !SKIP_BIOSTEST */
3550 * Test, if port_base is valid.
3553 static int aha152x_porttest(int io_port
)
3557 SETPORT(io_port
+ O_DMACNTRL1
, 0); /* reset stack pointer */
3558 for (i
= 0; i
< 16; i
++)
3559 SETPORT(io_port
+ O_STACK
, i
);
3561 SETPORT(io_port
+ O_DMACNTRL1
, 0); /* reset stack pointer */
3562 for (i
= 0; i
< 16 && GETPORT(io_port
+ O_STACK
) == i
; i
++)
3568 static int tc1550_porttest(int io_port
)
3572 SETPORT(io_port
+ O_TC_DMACNTRL1
, 0); /* reset stack pointer */
3573 for (i
= 0; i
< 16; i
++)
3574 SETPORT(io_port
+ O_STACK
, i
);
3576 SETPORT(io_port
+ O_TC_DMACNTRL1
, 0); /* reset stack pointer */
3577 for (i
= 0; i
< 16 && GETPORT(io_port
+ O_TC_STACK
) == i
; i
++)
3584 static int checksetup(struct aha152x_setup
*setup
)
3587 for (i
= 0; i
< ARRAY_SIZE(ports
) && (setup
->io_port
!= ports
[i
]); i
++)
3590 if (i
== ARRAY_SIZE(ports
))
3593 if ( request_region(setup
->io_port
, IO_RANGE
, "aha152x")==0 ) {
3594 printk(KERN_ERR
"aha152x: io port 0x%x busy.\n", setup
->io_port
);
3598 if( aha152x_porttest(setup
->io_port
) ) {
3600 } else if( tc1550_porttest(setup
->io_port
) ) {
3603 release_region(setup
->io_port
, IO_RANGE
);
3607 release_region(setup
->io_port
, IO_RANGE
);
3609 if ((setup
->irq
< IRQ_MIN
) || (setup
->irq
> IRQ_MAX
))
3612 if ((setup
->scsiid
< 0) || (setup
->scsiid
> 7))
3615 if ((setup
->reconnect
< 0) || (setup
->reconnect
> 1))
3618 if ((setup
->parity
< 0) || (setup
->parity
> 1))
3621 if ((setup
->synchronous
< 0) || (setup
->synchronous
> 1))
3624 if ((setup
->ext_trans
< 0) || (setup
->ext_trans
> 1))
3632 static int __init
aha152x_init(void)
3635 #if defined(AUTOCONF)
3636 aha152x_config conf
;
3639 struct pnp_dev
*dev
=NULL
, *pnpdev
[2] = {NULL
, NULL
};
3642 if ( setup_count
) {
3643 printk(KERN_INFO
"aha152x: processing commandline: ");
3645 for (i
= 0; i
<setup_count
; i
++) {
3646 if (!checksetup(&setup
[i
])) {
3647 printk(KERN_ERR
"\naha152x: %s\n", setup
[i
].conf
);
3648 printk(KERN_ERR
"aha152x: invalid line\n");
3655 if (setup_count
< ARRAY_SIZE(setup
)) {
3656 struct aha152x_setup override
= SETUP0
;
3658 if (setup_count
== 0 || (override
.io_port
!= setup
[0].io_port
)) {
3659 if (!checksetup(&override
)) {
3660 printk(KERN_ERR
"\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3666 override
.synchronous
,
3668 override
.ext_trans
);
3670 setup
[setup_count
++] = override
;
3676 if (setup_count
< ARRAY_SIZE(setup
)) {
3677 struct aha152x_setup override
= SETUP1
;
3679 if (setup_count
== 0 || (override
.io_port
!= setup
[0].io_port
)) {
3680 if (!checksetup(&override
)) {
3681 printk(KERN_ERR
"\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3687 override
.synchronous
,
3689 override
.ext_trans
);
3691 setup
[setup_count
++] = override
;
3697 if (setup_count
<ARRAY_SIZE(setup
) && (aha152x
[0]!=0 || io
[0]!=0 || irq
[0]!=0)) {
3699 setup
[setup_count
].conf
= "";
3700 setup
[setup_count
].io_port
= aha152x
[0];
3701 setup
[setup_count
].irq
= aha152x
[1];
3702 setup
[setup_count
].scsiid
= aha152x
[2];
3703 setup
[setup_count
].reconnect
= aha152x
[3];
3704 setup
[setup_count
].parity
= aha152x
[4];
3705 setup
[setup_count
].synchronous
= aha152x
[5];
3706 setup
[setup_count
].delay
= aha152x
[6];
3707 setup
[setup_count
].ext_trans
= aha152x
[7];
3708 #if defined(AHA152X_DEBUG)
3709 setup
[setup_count
].debug
= aha152x
[8];
3711 } else if(io
[0]!=0 || irq
[0]!=0) {
3712 if(io
[0]!=0) setup
[setup_count
].io_port
= io
[0];
3713 if(irq
[0]!=0) setup
[setup_count
].irq
= irq
[0];
3715 setup
[setup_count
].scsiid
= scsiid
[0];
3716 setup
[setup_count
].reconnect
= reconnect
[0];
3717 setup
[setup_count
].parity
= parity
[0];
3718 setup
[setup_count
].synchronous
= sync
[0];
3719 setup
[setup_count
].delay
= delay
[0];
3720 setup
[setup_count
].ext_trans
= exttrans
[0];
3721 #if defined(AHA152X_DEBUG)
3722 setup
[setup_count
].debug
= debug
[0];
3726 if (checksetup(&setup
[setup_count
]))
3729 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",
3730 setup
[setup_count
].io_port
,
3731 setup
[setup_count
].irq
,
3732 setup
[setup_count
].scsiid
,
3733 setup
[setup_count
].reconnect
,
3734 setup
[setup_count
].parity
,
3735 setup
[setup_count
].synchronous
,
3736 setup
[setup_count
].delay
,
3737 setup
[setup_count
].ext_trans
);
3740 if (setup_count
<ARRAY_SIZE(setup
) && (aha152x1
[0]!=0 || io
[1]!=0 || irq
[1]!=0)) {
3741 if(aha152x1
[0]!=0) {
3742 setup
[setup_count
].conf
= "";
3743 setup
[setup_count
].io_port
= aha152x1
[0];
3744 setup
[setup_count
].irq
= aha152x1
[1];
3745 setup
[setup_count
].scsiid
= aha152x1
[2];
3746 setup
[setup_count
].reconnect
= aha152x1
[3];
3747 setup
[setup_count
].parity
= aha152x1
[4];
3748 setup
[setup_count
].synchronous
= aha152x1
[5];
3749 setup
[setup_count
].delay
= aha152x1
[6];
3750 setup
[setup_count
].ext_trans
= aha152x1
[7];
3751 #if defined(AHA152X_DEBUG)
3752 setup
[setup_count
].debug
= aha152x1
[8];
3754 } else if(io
[1]!=0 || irq
[1]!=0) {
3755 if(io
[1]!=0) setup
[setup_count
].io_port
= io
[1];
3756 if(irq
[1]!=0) setup
[setup_count
].irq
= irq
[1];
3758 setup
[setup_count
].scsiid
= scsiid
[1];
3759 setup
[setup_count
].reconnect
= reconnect
[1];
3760 setup
[setup_count
].parity
= parity
[1];
3761 setup
[setup_count
].synchronous
= sync
[1];
3762 setup
[setup_count
].delay
= delay
[1];
3763 setup
[setup_count
].ext_trans
= exttrans
[1];
3764 #if defined(AHA152X_DEBUG)
3765 setup
[setup_count
].debug
= debug
[1];
3768 if (checksetup(&setup
[setup_count
]))
3771 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",
3772 setup
[setup_count
].io_port
,
3773 setup
[setup_count
].irq
,
3774 setup
[setup_count
].scsiid
,
3775 setup
[setup_count
].reconnect
,
3776 setup
[setup_count
].parity
,
3777 setup
[setup_count
].synchronous
,
3778 setup
[setup_count
].delay
,
3779 setup
[setup_count
].ext_trans
);
3784 for(i
=0; setup_count
<ARRAY_SIZE(setup
) && id_table
[i
].vendor
; i
++) {
3785 while ( setup_count
<ARRAY_SIZE(setup
) &&
3786 (dev
=pnp_find_dev(NULL
, id_table
[i
].vendor
, id_table
[i
].function
, dev
)) ) {
3787 if (pnp_device_attach(dev
) < 0)
3790 if (pnp_activate_dev(dev
) < 0) {
3791 pnp_device_detach(dev
);
3795 if (!pnp_port_valid(dev
, 0)) {
3796 pnp_device_detach(dev
);
3800 if (setup_count
==1 && pnp_port_start(dev
, 0)==setup
[0].io_port
) {
3801 pnp_device_detach(dev
);
3805 setup
[setup_count
].io_port
= pnp_port_start(dev
, 0);
3806 setup
[setup_count
].irq
= pnp_irq(dev
, 0);
3807 setup
[setup_count
].scsiid
= 7;
3808 setup
[setup_count
].reconnect
= 1;
3809 setup
[setup_count
].parity
= 1;
3810 setup
[setup_count
].synchronous
= 1;
3811 setup
[setup_count
].delay
= DELAY_DEFAULT
;
3812 setup
[setup_count
].ext_trans
= 0;
3813 #if defined(AHA152X_DEBUG)
3814 setup
[setup_count
].debug
= DEBUG_DEFAULT
;
3816 #if defined(__ISAPNP__)
3817 pnpdev
[setup_count
] = dev
;
3820 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3821 setup
[setup_count
].io_port
, setup
[setup_count
].irq
);
3827 #if defined(AUTOCONF)
3828 if (setup_count
<ARRAY_SIZE(setup
)) {
3829 #if !defined(SKIP_BIOSTEST)
3831 for (i
= 0; i
< ARRAY_SIZE(addresses
) && !ok
; i
++) {
3832 void __iomem
*p
= ioremap(addresses
[i
], 0x4000);
3835 for (j
= 0; j
<ARRAY_SIZE(signatures
) && !ok
; j
++)
3836 ok
= check_signature(p
+ signatures
[j
].sig_offset
,
3837 signatures
[j
].signature
, signatures
[j
].sig_length
);
3840 if (!ok
&& setup_count
== 0)
3843 printk(KERN_INFO
"aha152x: BIOS test: passed, ");
3845 printk(KERN_INFO
"aha152x: ");
3846 #endif /* !SKIP_BIOSTEST */
3849 for (i
= 0; i
< ARRAY_SIZE(ports
) && setup_count
< 2; i
++) {
3850 if ((setup_count
== 1) && (setup
[0].io_port
== ports
[i
]))
3853 if ( request_region(ports
[i
], IO_RANGE
, "aha152x")==0 ) {
3854 printk(KERN_ERR
"aha152x: io port 0x%x busy.\n", ports
[i
]);
3858 if (aha152x_porttest(ports
[i
])) {
3859 setup
[setup_count
].tc1550
= 0;
3862 (GETPORT(ports
[i
] + O_PORTA
) << 8) + GETPORT(ports
[i
] + O_PORTB
);
3863 } else if (tc1550_porttest(ports
[i
])) {
3864 setup
[setup_count
].tc1550
= 1;
3867 (GETPORT(ports
[i
] + O_TC_PORTA
) << 8) + GETPORT(ports
[i
] + O_TC_PORTB
);
3869 release_region(ports
[i
], IO_RANGE
);
3873 release_region(ports
[i
], IO_RANGE
);
3876 setup
[setup_count
].io_port
= ports
[i
];
3877 setup
[setup_count
].irq
= IRQ_MIN
+ conf
.cf_irq
;
3878 setup
[setup_count
].scsiid
= conf
.cf_id
;
3879 setup
[setup_count
].reconnect
= conf
.cf_tardisc
;
3880 setup
[setup_count
].parity
= !conf
.cf_parity
;
3881 setup
[setup_count
].synchronous
= conf
.cf_syncneg
;
3882 setup
[setup_count
].delay
= DELAY_DEFAULT
;
3883 setup
[setup_count
].ext_trans
= 0;
3884 #if defined(AHA152X_DEBUG)
3885 setup
[setup_count
].debug
= DEBUG_DEFAULT
;
3892 printk("auto configuration: ok, ");
3896 printk("%d controller(s) configured\n", setup_count
);
3898 for (i
=0; i
<setup_count
; i
++) {
3899 if ( request_region(setup
[i
].io_port
, IO_RANGE
, "aha152x") ) {
3900 struct Scsi_Host
*shpnt
= aha152x_probe_one(&setup
[i
]);
3903 release_region(setup
[i
].io_port
, IO_RANGE
);
3904 #if defined(__ISAPNP__)
3905 } else if( pnpdev
[i
] ) {
3906 HOSTDATA(shpnt
)->pnpdev
=pnpdev
[i
];
3911 printk(KERN_ERR
"aha152x: io port 0x%x busy.\n", setup
[i
].io_port
);
3914 #if defined(__ISAPNP__)
3916 pnp_device_detach(pnpdev
[i
]);
3920 return registered_count
>0;
3923 static void __exit
aha152x_exit(void)
3927 for(i
=0; i
<ARRAY_SIZE(setup
); i
++) {
3928 aha152x_release(aha152x_host
[i
]);
3929 aha152x_host
[i
]=NULL
;
3933 module_init(aha152x_init
);
3934 module_exit(aha152x_exit
);
3936 #if !defined(MODULE)
3937 static int __init
aha152x_setup(char *str
)
3939 #if defined(AHA152X_DEBUG)
3944 get_options(str
, ARRAY_SIZE(ints
), ints
);
3946 if(setup_count
>=ARRAY_SIZE(setup
)) {
3947 printk(KERN_ERR
"aha152x: you can only configure up to two controllers\n");
3951 setup
[setup_count
].conf
= str
;
3952 setup
[setup_count
].io_port
= ints
[0] >= 1 ? ints
[1] : 0x340;
3953 setup
[setup_count
].irq
= ints
[0] >= 2 ? ints
[2] : 11;
3954 setup
[setup_count
].scsiid
= ints
[0] >= 3 ? ints
[3] : 7;
3955 setup
[setup_count
].reconnect
= ints
[0] >= 4 ? ints
[4] : 1;
3956 setup
[setup_count
].parity
= ints
[0] >= 5 ? ints
[5] : 1;
3957 setup
[setup_count
].synchronous
= ints
[0] >= 6 ? ints
[6] : 1;
3958 setup
[setup_count
].delay
= ints
[0] >= 7 ? ints
[7] : DELAY_DEFAULT
;
3959 setup
[setup_count
].ext_trans
= ints
[0] >= 8 ? ints
[8] : 0;
3960 #if defined(AHA152X_DEBUG)
3961 setup
[setup_count
].debug
= ints
[0] >= 9 ? ints
[9] : DEBUG_DEFAULT
;
3963 printk(KERN_NOTICE
"aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3964 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3966 if (ints
[0] > 8) { /*}*/
3967 printk(KERN_NOTICE
"aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3968 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3977 __setup("aha152x=", aha152x_setup
);
3980 #endif /* !PCMCIA */