1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* aha152x.c -- Adaptec AHA-152x driver
3 * Author: Jürgen E. Fischer, fischer@norbit.de
4 * Copyright 1993-2004 Jürgen E. Fischer
6 * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
9 * Revision 2.7 2004/01/24 11:42:59 fischer
10 * - gather code that is not used by PCMCIA at the end
11 * - move request_region for !PCMCIA case to detection
12 * - migration to new scsi host api (remove legacy code)
13 * - free host scribble before scsi_done
14 * - fix error handling
15 * - one isapnp device added to id_table
17 * Revision 2.6 2003/10/30 20:52:47 fischer
18 * - interfaces changes for kernel 2.6
19 * - aha152x_probe_one introduced for pcmcia stub
20 * - fixed pnpdev handling
21 * - instead of allocation a new one, reuse command for request sense after check condition and reset
22 * - fixes race in is_complete
24 * Revision 2.5 2002/04/14 11:24:53 fischer
29 * Revision 2.4 2000/12/16 12:53:56 fischer
30 * - allow REQUEST SENSE to be queued
31 * - handle shared PCI interrupts
33 * Revision 2.3 2000/11/04 16:40:26 fischer
34 * - handle data overruns
35 * - extend timeout for data phases
37 * Revision 2.2 2000/08/08 19:54:53 fischer
40 * Revision 2.1 2000/05/17 16:23:17 fischer
42 * - fix for data out w/o scatter gather
44 * Revision 2.0 1999/12/25 15:07:32 fischer
45 * - interrupt routine completly reworked
46 * - basic support for new eh code
48 * Revision 1.21 1999/11/10 23:46:36 fischer
49 * - default to synchronous operation
50 * - synchronous negotiation fixed
51 * - added timeout to loops
52 * - debugging output can be controlled through procfs
54 * Revision 1.20 1999/11/07 18:37:31 fischer
55 * - synchronous operation works
56 * - resid support for sg driver
58 * Revision 1.19 1999/11/02 22:39:59 fischer
59 * - moved leading comments to README.aha152x
60 * - new additional module parameters
62 * - support for the Tripace TC1550 controller
63 * - interrupt handling changed
65 * Revision 1.18 1996/09/07 20:10:40 fischer
66 * - fixed can_queue handling (multiple outstanding commands working again)
68 * Revision 1.17 1996/08/17 16:05:14 fischer
69 * - biosparam improved
70 * - interrupt verification
71 * - updated documentation
74 * Revision 1.16 1996/06/09 00:04:56 root
75 * - added configuration symbols for insmod (aha152x/aha152x1)
77 * Revision 1.15 1996/04/30 14:52:06 fischer
79 * - support for extended translation for >1GB disks
81 * Revision 1.14 1996/01/17 15:11:20 fischer
82 * - fixed lockup in MESSAGE IN phase after reconnection
84 * Revision 1.13 1996/01/09 02:15:53 fischer
86 * - moved request_irq behind controller initialization
87 * (to avoid spurious interrupts)
89 * Revision 1.12 1995/12/16 12:26:07 fischer
91 * - configurable RESET delay added
93 * Revision 1.11 1995/12/06 21:18:35 fischer
94 * - some minor updates
96 * Revision 1.10 1995/07/22 19:18:45 fischer
97 * - support for 2 controllers
98 * - started synchronous data transfers (not working yet)
100 * Revision 1.9 1995/03/18 09:20:24 root
101 * - patches for PCMCIA and modules
103 * Revision 1.8 1995/01/21 22:07:19 root
104 * - snarf_region => request_region
105 * - aha152x_intr interface change
107 * Revision 1.7 1995/01/02 23:19:36 root
108 * - updated COMMAND_SIZE to cmd_len
109 * - changed sti() to restore_flags()
110 * - fixed some #ifdef which generated warnings
112 * Revision 1.6 1994/11/24 20:35:27 root
113 * - problem with odd number of bytes in fifo fixed
115 * Revision 1.5 1994/10/30 14:39:56 root
117 * - debugging improved
119 * Revision 1.4 1994/09/12 11:33:01 root
120 * - irqaction to request_irq
123 * Revision 1.3 1994/08/04 13:53:05 root
124 * - updates for mid-level-driver changes
125 * - accept unexpected BUSFREE phase as error condition
126 * - parity check now configurable
128 * Revision 1.2 1994/07/03 12:56:36 root
129 * - cleaned up debugging code
130 * - more tweaking on reset delays
131 * - updated abort/reset code (pretty untested...)
133 * Revision 1.1 1994/05/28 21:18:49 root
134 * - update for mid-level interface change (abort-reset)
135 * - delays after resets adjusted for some slow devices
137 * Revision 1.0 1994/03/25 12:52:00 root
138 * - Fixed "more data than expected" problem
139 * - added new BIOS signatures
141 * Revision 0.102 1994/01/31 20:44:12 root
142 * - minor changes in insw/outsw handling
144 * Revision 0.101 1993/12/13 01:16:27 root
145 * - fixed STATUS phase (non-GOOD stati were dropped sometimes;
146 * fixes problems with CD-ROM sector size detection & media change)
148 * Revision 0.100 1993/12/10 16:58:47 root
149 * - fix for unsuccessful selections in case of non-continuous id assignments
152 * Revision 0.99 1993/10/24 16:19:59 root
153 * - fixed DATA IN (rare read errors gone)
155 * Revision 0.98 1993/10/17 12:54:44 root
156 * - fixed some recent fixes (shame on me)
157 * - moved initialization of scratch area to aha152x_queue
159 * Revision 0.97 1993/10/09 18:53:53 root
160 * - DATA IN fixed. Rarely left data in the fifo.
162 * Revision 0.96 1993/10/03 00:53:59 root
163 * - minor changes on DATA IN
165 * Revision 0.95 1993/09/24 10:36:01 root
166 * - change handling of MSGI after reselection
170 * Revision 0.94 1993/09/18 14:08:22 root
171 * - fixed bug in multiple outstanding command code
172 * - changed detection
173 * - support for kernel command line configuration
175 * - changed message handling
177 * Revision 0.93 1993/09/15 20:41:19 root
178 * - fixed bugs with multiple outstanding commands
180 * Revision 0.92 1993/09/13 02:46:33 root
181 * - multiple outstanding commands work (no problems with IBM drive)
183 * Revision 0.91 1993/09/12 20:51:46 root
184 * added multiple outstanding commands
185 * (some problem with this $%&? IBM device remain)
187 * Revision 0.9 1993/09/12 11:11:22 root
188 * - corrected auto-configuration
189 * - changed the auto-configuration (added some '#define's)
190 * - added support for dis-/reconnection
192 * Revision 0.8 1993/09/06 23:09:39 root
193 * - added support for the drive activity light
196 * Revision 0.7 1993/09/05 14:30:15 root
197 * - improved phase detection
198 * - now using the new snarf_region code of 0.99pl13
200 * Revision 0.6 1993/09/02 11:01:38 root
201 * first public release; added some signatures and biosparam()
203 * Revision 0.5 1993/08/30 10:23:30 root
204 * fixed timing problems with my IBM drive
206 * Revision 0.4 1993/08/29 14:06:52 root
207 * fixed some problems with timeouts due incomplete commands
209 * Revision 0.3 1993/08/28 15:55:03 root
210 * writing data works too. mounted and worked on a dos partition
212 * Revision 0.2 1993/08/27 22:42:07 root
213 * reading data works. Mounted a msdos partition.
215 * Revision 0.1 1993/08/25 13:38:30 root
216 * first "damn thing doesn't work" version
218 * Revision 0.0 1993/08/14 19:54:25 root
219 * empty function bodies; detect() works.
221 **************************************************************************
223 see Documentation/scsi/aha152x.rst for configuration details
225 **************************************************************************/
227 #include <linux/module.h>
229 #include <linux/io.h>
230 #include <linux/blkdev.h>
231 #include <linux/completion.h>
232 #include <linux/errno.h>
233 #include <linux/string.h>
234 #include <linux/wait.h>
235 #include <linux/ioport.h>
236 #include <linux/delay.h>
237 #include <linux/proc_fs.h>
238 #include <linux/interrupt.h>
239 #include <linux/init.h>
240 #include <linux/kernel.h>
241 #include <linux/isapnp.h>
242 #include <linux/spinlock.h>
243 #include <linux/workqueue.h>
244 #include <linux/list.h>
245 #include <linux/slab.h>
246 #include <scsi/scsicam.h>
249 #include <scsi/scsi_dbg.h>
250 #include <scsi/scsi_host.h>
251 #include <scsi/scsi_transport_spi.h>
252 #include <scsi/scsi_eh.h>
255 static LIST_HEAD(aha152x_host_list);
260 /* For PCMCIA cards, always use AUTOCONF */
261 #if defined(AHA152X_PCMCIA) || defined(MODULE)
262 #if !defined(AUTOCONF)
267 #if !defined(AUTOCONF) && !defined(SETUP0)
268 #error define AUTOCONF or SETUP0
271 #define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
272 #define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
274 #define LEAD "(scsi%d:%d:%d) "
275 #define INFO_LEAD KERN_INFO LEAD
276 #define CMDINFO(cmd) \
277 (cmd) ? ((cmd)->device->host->host_no) : -1, \
278 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
279 (cmd) ? ((u8)(cmd)->device->lun & 0x07) : -1
282 CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
284 scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
287 #define DELAY_DEFAULT 1000
289 #if defined(AHA152X_PCMCIA)
295 #define IRQ_MAX (nr_irqs-1)
302 not_issued = 0x0001, /* command not yet issued */
303 selecting = 0x0002, /* target is being selected */
304 identified = 0x0004, /* IDENTIFY was sent */
305 disconnected = 0x0008, /* target disconnected */
306 completed = 0x0010, /* target sent COMMAND COMPLETE */
307 aborted = 0x0020, /* ABORT was sent */
308 resetted = 0x0040, /* BUS DEVICE RESET was sent */
309 spiordy = 0x0080, /* waiting for SPIORDY to raise */
310 syncneg = 0x0100, /* synchronous negotiation in progress */
311 aborting = 0x0200, /* ABORT is pending */
312 resetting = 0x0400, /* BUS DEVICE RESET is pending */
313 check_condition = 0x0800, /* requesting sense after CHECK CONDITION */
316 MODULE_AUTHOR("Jürgen Fischer");
317 MODULE_DESCRIPTION(AHA152X_REVID);
318 MODULE_LICENSE("GPL");
320 #if !defined(AHA152X_PCMCIA)
322 static int io[] = {0, 0};
323 module_param_hw_array(io, int, ioport, NULL, 0);
324 MODULE_PARM_DESC(io,"base io address of controller");
326 static int irq[] = {0, 0};
327 module_param_hw_array(irq, int, irq, NULL, 0);
328 MODULE_PARM_DESC(irq,"interrupt for controller");
330 static int scsiid[] = {7, 7};
331 module_param_array(scsiid, int, NULL, 0);
332 MODULE_PARM_DESC(scsiid,"scsi id of controller");
334 static int reconnect[] = {1, 1};
335 module_param_array(reconnect, int, NULL, 0);
336 MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
338 static int parity[] = {1, 1};
339 module_param_array(parity, int, NULL, 0);
340 MODULE_PARM_DESC(parity,"use scsi parity");
342 static int sync[] = {1, 1};
343 module_param_array(sync, int, NULL, 0);
344 MODULE_PARM_DESC(sync,"use synchronous transfers");
346 static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
347 module_param_array(delay, int, NULL, 0);
348 MODULE_PARM_DESC(delay,"scsi reset delay");
350 static int exttrans[] = {0, 0};
351 module_param_array(exttrans, int, NULL, 0);
352 MODULE_PARM_DESC(exttrans,"use extended translation");
354 static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
355 module_param_array(aha152x, int, NULL, 0);
356 MODULE_PARM_DESC(aha152x, "parameters for first controller");
358 static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
359 module_param_array(aha152x1, int, NULL, 0);
360 MODULE_PARM_DESC(aha152x1, "parameters for second controller");
364 static struct isapnp_device_id id_table[] = {
365 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
366 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
367 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
368 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
369 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
370 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
371 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
372 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
373 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
374 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
375 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
376 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
377 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
378 { ISAPNP_DEVICE_SINGLE_END, }
380 MODULE_DEVICE_TABLE(isapnp, id_table);
383 #endif /* !AHA152X_PCMCIA */
385 static struct scsi_host_template aha152x_driver_template;
388 * internal states of the host
410 * current state information of the host
413 struct aha152x_hostdata {
414 struct scsi_cmnd *issue_SC;
415 /* pending commands to issue */
417 struct scsi_cmnd *current_SC;
418 /* current command on the bus */
420 struct scsi_cmnd *disconnected_SC;
421 /* commands that disconnected */
423 struct scsi_cmnd *done_SC;
424 /* command that was completed */
429 #if defined(AHA152X_STAT)
432 int busfree_without_any_action;
433 int busfree_without_old_command;
434 int busfree_without_new_command;
435 int busfree_without_done_command;
436 int busfree_with_check_condition;
438 int count_trans[maxstate];
439 unsigned long time[maxstate];
442 int commands; /* current number of commands */
444 int reconnect; /* disconnection allowed */
445 int parity; /* parity checking enabled */
446 int synchronous; /* synchronous transferes enabled */
447 int delay; /* reset out delay */
448 int ext_trans; /* extended translation enabled */
450 int swint; /* software-interrupt was fired during detect() */
451 int service; /* bh needs to be run */
452 int in_intr; /* bh is running */
456 last state different from current state */
457 enum aha152x_state state, prevstate, laststate;
460 /* reconnecting target */
462 unsigned char syncrate[8];
463 /* current synchronous transfer agreements */
465 unsigned char syncneg[8];
466 /* 0: no negotiation;
467 * 1: negotiation in progress;
468 * 2: negotiation completed
472 /* number of sent bytes of current command */
475 /* number of received message bytes */
476 unsigned char msgi[256];
477 /* received message bytes */
479 int msgo_i, msgo_len;
480 /* number of sent bytes and length of current messages */
481 unsigned char msgo[256];
482 /* pending messages */
485 /* number of sent/received bytes in dataphase */
487 unsigned long io_port0;
488 unsigned long io_port1;
491 struct pnp_dev *pnpdev;
493 struct list_head host_list;
498 * host specific command extension
501 struct aha152x_scdata {
502 struct scsi_cmnd *next; /* next sc in queue */
503 struct completion *done;/* semaphore to block on */
504 struct scsi_eh_save ses;
507 /* access macros for hostdata */
509 #define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
511 #define HOSTNO ((shpnt)->host_no)
513 #define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
514 #define DONE_SC (HOSTDATA(shpnt)->done_SC)
515 #define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
516 #define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
517 #define QLOCK (HOSTDATA(shpnt)->lock)
518 #define QLOCKER (HOSTDATA(shpnt)->locker)
519 #define QLOCKERL (HOSTDATA(shpnt)->lockerl)
521 #define STATE (HOSTDATA(shpnt)->state)
522 #define PREVSTATE (HOSTDATA(shpnt)->prevstate)
523 #define LASTSTATE (HOSTDATA(shpnt)->laststate)
525 #define RECONN_TARGET (HOSTDATA(shpnt)->target)
527 #define CMD_I (HOSTDATA(shpnt)->cmd_i)
529 #define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
530 #define MSGO_I (HOSTDATA(shpnt)->msgo_i)
531 #define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
532 #define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
534 #define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
535 #define MSGILEN (HOSTDATA(shpnt)->msgi_len)
536 #define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
538 #define DATA_LEN (HOSTDATA(shpnt)->data_len)
540 #define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
541 #define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
543 #define DELAY (HOSTDATA(shpnt)->delay)
544 #define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
545 #define TC1550 (HOSTDATA(shpnt)->tc1550)
546 #define RECONNECT (HOSTDATA(shpnt)->reconnect)
547 #define PARITY (HOSTDATA(shpnt)->parity)
548 #define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
550 #define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
551 #define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
553 #define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
554 #define SCNEXT(SCpnt) SCDATA(SCpnt)->next
555 #define SCSEM(SCpnt) SCDATA(SCpnt)->done
557 #define SG_ADDRESS(buffer) ((char *) sg_virt((buffer)))
560 static void seldi_run(struct Scsi_Host *shpnt);
561 static void seldo_run(struct Scsi_Host *shpnt);
562 static void selto_run(struct Scsi_Host *shpnt);
563 static void busfree_run(struct Scsi_Host *shpnt);
565 static void msgo_init(struct Scsi_Host *shpnt);
566 static void msgo_run(struct Scsi_Host *shpnt);
567 static void msgo_end(struct Scsi_Host *shpnt);
569 static void cmd_init(struct Scsi_Host *shpnt);
570 static void cmd_run(struct Scsi_Host *shpnt);
571 static void cmd_end(struct Scsi_Host *shpnt);
573 static void datai_init(struct Scsi_Host *shpnt);
574 static void datai_run(struct Scsi_Host *shpnt);
575 static void datai_end(struct Scsi_Host *shpnt);
577 static void datao_init(struct Scsi_Host *shpnt);
578 static void datao_run(struct Scsi_Host *shpnt);
579 static void datao_end(struct Scsi_Host *shpnt);
581 static void status_run(struct Scsi_Host *shpnt);
583 static void msgi_run(struct Scsi_Host *shpnt);
584 static void msgi_end(struct Scsi_Host *shpnt);
586 static void parerr_run(struct Scsi_Host *shpnt);
587 static void rsti_run(struct Scsi_Host *shpnt);
589 static void is_complete(struct Scsi_Host *shpnt);
597 void (*init)(struct Scsi_Host *);
598 void (*run)(struct Scsi_Host *);
599 void (*end)(struct Scsi_Host *);
602 { "idle", NULL, NULL, NULL, 0},
603 { "unknown", NULL, NULL, NULL, 0},
604 { "seldo", NULL, seldo_run, NULL, 0},
605 { "seldi", NULL, seldi_run, NULL, 0},
606 { "selto", NULL, selto_run, NULL, 0},
607 { "busfree", NULL, busfree_run, NULL, 0},
608 { "msgo", msgo_init, msgo_run, msgo_end, 1},
609 { "cmd", cmd_init, cmd_run, cmd_end, 1},
610 { "msgi", NULL, msgi_run, msgi_end, 1},
611 { "status", NULL, status_run, NULL, 1},
612 { "datai", datai_init, datai_run, datai_end, 0},
613 { "datao", datao_init, datao_run, datao_end, 0},
614 { "parerr", NULL, parerr_run, NULL, 0},
615 { "rsti", NULL, rsti_run, NULL, 0},
618 /* setup & interrupt */
619 static irqreturn_t intr(int irq, void *dev_id);
620 static void reset_ports(struct Scsi_Host *shpnt);
621 static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
622 static void done(struct Scsi_Host *shpnt, unsigned char status_byte,
623 unsigned char host_byte);
626 static void show_command(struct scsi_cmnd * ptr);
627 static void show_queues(struct Scsi_Host *shpnt);
628 static void disp_enintr(struct Scsi_Host *shpnt);
635 static inline void append_SC(struct scsi_cmnd **SC, struct scsi_cmnd *new_SC)
637 struct scsi_cmnd *end;
639 SCNEXT(new_SC) = NULL;
643 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
645 SCNEXT(end) = new_SC;
649 static inline struct scsi_cmnd *remove_first_SC(struct scsi_cmnd ** SC)
651 struct scsi_cmnd *ptr;
661 static inline struct scsi_cmnd *remove_lun_SC(struct scsi_cmnd ** SC,
664 struct scsi_cmnd *ptr, *prev;
666 for (ptr = *SC, prev = NULL;
667 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
668 prev = ptr, ptr = SCNEXT(ptr))
673 SCNEXT(prev) = SCNEXT(ptr);
683 static inline struct scsi_cmnd *remove_SC(struct scsi_cmnd **SC,
684 struct scsi_cmnd *SCp)
686 struct scsi_cmnd *ptr, *prev;
688 for (ptr = *SC, prev = NULL;
690 prev = ptr, ptr = SCNEXT(ptr))
695 SCNEXT(prev) = SCNEXT(ptr);
705 static irqreturn_t swintr(int irqno, void *dev_id)
707 struct Scsi_Host *shpnt = dev_id;
709 HOSTDATA(shpnt)->swint++;
711 SETPORT(DMACNTRL0, INTEN);
715 struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
717 struct Scsi_Host *shpnt;
719 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
721 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
725 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
726 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
728 /* need to have host registered before triggering any interrupt */
729 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
731 shpnt->io_port = setup->io_port;
732 shpnt->n_io_port = IO_RANGE;
733 shpnt->irq = setup->irq;
735 if (!setup->tc1550) {
736 HOSTIOPORT0 = setup->io_port;
737 HOSTIOPORT1 = setup->io_port;
739 HOSTIOPORT0 = setup->io_port+0x10;
740 HOSTIOPORT1 = setup->io_port-0x10;
743 spin_lock_init(&QLOCK);
744 RECONNECT = setup->reconnect;
745 SYNCHRONOUS = setup->synchronous;
746 PARITY = setup->parity;
747 DELAY = setup->delay;
748 EXT_TRANS = setup->ext_trans;
750 SETPORT(SCSIID, setup->scsiid << 4);
751 shpnt->this_id = setup->scsiid;
753 if (setup->reconnect)
754 shpnt->can_queue = AHA152X_MAXQUEUE;
757 printk("aha152x: resetting bus...\n");
758 SETPORT(SCSISEQ, SCSIRSTO);
767 "vital data: rev=%x, "
768 "io=0x%03lx (0x%03lx/0x%03lx), "
775 "extended translation=%s\n",
776 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
778 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
781 RECONNECT ? "enabled" : "disabled",
782 PARITY ? "enabled" : "disabled",
783 SYNCHRONOUS ? "enabled" : "disabled",
785 EXT_TRANS ? "enabled" : "disabled");
787 /* not expecting any interrupts */
791 if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) {
792 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
796 HOSTDATA(shpnt)->swint = 0;
798 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
801 SETPORT(DMACNTRL0, SWINT|INTEN);
803 free_irq(shpnt->irq, shpnt);
805 if (!HOSTDATA(shpnt)->swint) {
806 if (TESTHI(DMASTAT, INTSTAT)) {
812 SETPORT(DMACNTRL0, INTEN);
814 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
815 "Please verify.\n", shpnt->host_no, shpnt->irq);
821 /* clear interrupts */
822 SETPORT(SSTAT0, 0x7f);
823 SETPORT(SSTAT1, 0xef);
825 if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) {
826 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
830 if( scsi_add_host(shpnt, NULL) ) {
831 free_irq(shpnt->irq, shpnt);
832 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
836 scsi_scan_host(shpnt);
841 list_del(&HOSTDATA(shpnt)->host_list);
842 scsi_host_put(shpnt);
847 void aha152x_release(struct Scsi_Host *shpnt)
852 scsi_remove_host(shpnt);
854 free_irq(shpnt->irq, shpnt);
856 #if !defined(AHA152X_PCMCIA)
858 release_region(shpnt->io_port, IO_RANGE);
862 if (HOSTDATA(shpnt)->pnpdev)
863 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
866 list_del(&HOSTDATA(shpnt)->host_list);
867 scsi_host_put(shpnt);
872 * setup controller to generate interrupts depending
873 * on current state (lock has to be acquired)
876 static int setup_expected_interrupts(struct Scsi_Host *shpnt)
879 CURRENT_SC->SCp.phase |= 1 << 16;
881 if(CURRENT_SC->SCp.phase & selecting) {
882 SETPORT(SSTAT1, SELTO);
883 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
884 SETPORT(SIMODE1, ENSELTIMO);
886 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
887 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
889 } else if(STATE==seldi) {
891 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
893 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
894 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
897 if(!HOSTDATA(shpnt)->in_intr)
898 SETBITS(DMACNTRL0, INTEN);
900 return TESTHI(DMASTAT, INTSTAT);
905 * Queue a command and setup interrupts for a free bus.
907 static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
908 struct completion *complete,
909 int phase, void (*done)(struct scsi_cmnd *))
911 struct Scsi_Host *shpnt = SCpnt->device->host;
914 SCpnt->scsi_done = done;
915 SCpnt->SCp.phase = not_issued | phase;
916 SCpnt->SCp.Status = 0x1; /* Ilegal status by SCSI standard */
917 SCpnt->SCp.Message = 0;
918 SCpnt->SCp.have_data_in = 0;
919 SCpnt->SCp.sent_command = 0;
921 if(SCpnt->SCp.phase & (resetting|check_condition)) {
922 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
923 scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
927 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
928 if(!SCpnt->host_scribble) {
929 scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
934 SCNEXT(SCpnt) = NULL;
935 SCSEM(SCpnt) = complete;
937 /* setup scratch area
938 SCp.ptr : buffer pointer
939 SCp.this_residual : buffer length
940 SCp.buffer : next buffer
941 SCp.phase : current state of the command */
943 if ((phase & resetting) || !scsi_sglist(SCpnt)) {
944 SCpnt->SCp.ptr = NULL;
945 SCpnt->SCp.this_residual = 0;
946 scsi_set_resid(SCpnt, 0);
947 SCpnt->SCp.buffer = NULL;
949 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
950 SCpnt->SCp.buffer = scsi_sglist(SCpnt);
951 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
952 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
957 #if defined(AHA152X_STAT)
958 HOSTDATA(shpnt)->total_commands++;
961 /* Turn led on, when this is the first command. */
962 HOSTDATA(shpnt)->commands++;
963 if (HOSTDATA(shpnt)->commands==1)
966 append_SC(&ISSUE_SC, SCpnt);
968 if(!HOSTDATA(shpnt)->in_intr)
969 setup_expected_interrupts(shpnt);
980 static int aha152x_queue_lck(struct scsi_cmnd *SCpnt,
981 void (*done)(struct scsi_cmnd *))
983 return aha152x_internal_queue(SCpnt, NULL, 0, done);
986 static DEF_SCSI_QCMD(aha152x_queue)
992 static void reset_done(struct scsi_cmnd *SCpnt)
995 complete(SCSEM(SCpnt));
997 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1005 static int aha152x_abort(struct scsi_cmnd *SCpnt)
1007 struct Scsi_Host *shpnt = SCpnt->device->host;
1008 struct scsi_cmnd *ptr;
1009 unsigned long flags;
1013 ptr=remove_SC(&ISSUE_SC, SCpnt);
1016 HOSTDATA(shpnt)->commands--;
1017 if (!HOSTDATA(shpnt)->commands)
1021 kfree(SCpnt->host_scribble);
1022 SCpnt->host_scribble=NULL;
1031 * for current command: queue ABORT for message out and raise ATN
1032 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1036 scmd_printk(KERN_ERR, SCpnt,
1037 "cannot abort running or disconnected command\n");
1046 static int aha152x_device_reset(struct scsi_cmnd * SCpnt)
1048 struct Scsi_Host *shpnt = SCpnt->device->host;
1049 DECLARE_COMPLETION(done);
1050 int ret, issued, disconnected;
1051 unsigned char old_cmd_len = SCpnt->cmd_len;
1052 unsigned long flags;
1053 unsigned long timeleft;
1055 if(CURRENT_SC==SCpnt) {
1056 scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n");
1061 issued = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1062 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1067 aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1069 timeleft = wait_for_completion_timeout(&done, 100*HZ);
1071 /* remove command from issue queue */
1073 remove_SC(&ISSUE_SC, SCpnt);
1077 SCpnt->cmd_len = old_cmd_len;
1081 if(SCpnt->SCp.phase & resetted) {
1082 HOSTDATA(shpnt)->commands--;
1083 if (!HOSTDATA(shpnt)->commands)
1085 kfree(SCpnt->host_scribble);
1086 SCpnt->host_scribble=NULL;
1092 append_SC(&ISSUE_SC, SCpnt);
1093 } else if(disconnected) {
1094 append_SC(&DISCONNECTED_SC, SCpnt);
1104 static void free_hard_reset_SCs(struct Scsi_Host *shpnt,
1105 struct scsi_cmnd **SCs)
1107 struct scsi_cmnd *ptr;
1111 struct scsi_cmnd *next;
1116 scmd_printk(KERN_DEBUG, ptr,
1117 "queue corrupted at %p\n", ptr);
1121 if (!ptr->device->soft_reset) {
1122 remove_SC(SCs, ptr);
1123 HOSTDATA(shpnt)->commands--;
1124 kfree(ptr->host_scribble);
1125 ptr->host_scribble=NULL;
1135 * AIC-6260 has a hard reset (MRST signal), but apparently
1136 * one cannot trigger it via software. So live with
1137 * a soft reset; no-one seemed to have cared.
1139 static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1141 unsigned long flags;
1145 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1146 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1148 SETPORT(SCSISEQ, SCSIRSTO);
1150 SETPORT(SCSISEQ, 0);
1153 setup_expected_interrupts(shpnt);
1154 if(HOSTDATA(shpnt)->commands==0)
1166 static int aha152x_bus_reset(struct scsi_cmnd *SCpnt)
1168 return aha152x_bus_reset_host(SCpnt->device->host);
1172 * Restore default values to the AIC-6260 registers and reset the fifos
1175 static void reset_ports(struct Scsi_Host *shpnt)
1177 unsigned long flags;
1179 /* disable interrupts */
1180 SETPORT(DMACNTRL0, RSTFIFO);
1182 SETPORT(SCSISEQ, 0);
1184 SETPORT(SXFRCTL1, 0);
1185 SETPORT(SCSISIG, 0);
1188 /* clear all interrupt conditions */
1189 SETPORT(SSTAT0, 0x7f);
1190 SETPORT(SSTAT1, 0xef);
1192 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1194 SETPORT(DMACNTRL0, 0);
1195 SETPORT(DMACNTRL1, 0);
1197 SETPORT(BRSTCNTRL, 0xf1);
1199 /* clear SCSI fifos and transfer count */
1200 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1201 SETPORT(SXFRCTL0, CH1);
1204 setup_expected_interrupts(shpnt);
1209 * Reset the host (bus and controller)
1212 int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1214 aha152x_bus_reset_host(shpnt);
1221 * Return the "logical geometry"
1224 static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1225 sector_t capacity, int *info_array)
1227 struct Scsi_Host *shpnt = sdev->host;
1229 /* try default translation */
1232 info_array[2] = (unsigned long)capacity / (64 * 32);
1234 /* for disks >1GB do some guessing */
1235 if (info_array[2] >= 1024) {
1238 /* try to figure out the geometry from the partition table */
1239 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1240 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1243 "aha152x: unable to verify geometry for disk with >1GB.\n"
1244 " using extended translation.\n");
1245 info_array[0] = 255;
1247 info_array[2] = (unsigned long)capacity / (255 * 63);
1250 "aha152x: unable to verify geometry for disk with >1GB.\n"
1251 " Using default translation. Please verify yourself.\n"
1252 " Perhaps you need to enable extended translation in the driver.\n"
1253 " See Documentation/scsi/aha152x.rst for details.\n");
1256 info_array[0] = info[0];
1257 info_array[1] = info[1];
1258 info_array[2] = info[2];
1260 if (info[0] == 255 && !EXT_TRANS) {
1262 "aha152x: current partition table is using extended translation.\n"
1263 " using it also, although it's not explicitly enabled.\n");
1272 * Internal done function
1275 static void done(struct Scsi_Host *shpnt, unsigned char status_byte,
1276 unsigned char host_byte)
1280 scmd_printk(KERN_ERR, CURRENT_SC,
1281 "there's already a completed command %p "
1282 "- will cause abort\n", DONE_SC);
1284 DONE_SC = CURRENT_SC;
1286 set_status_byte(DONE_SC, status_byte);
1287 set_host_byte(DONE_SC, host_byte);
1289 printk(KERN_ERR "aha152x: done() called outside of command\n");
1292 static struct work_struct aha152x_tq;
1295 * Run service completions on the card with interrupts enabled.
1298 static void run(struct work_struct *work)
1300 struct aha152x_hostdata *hd;
1302 list_for_each_entry(hd, &aha152x_host_list, host_list) {
1303 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1313 static irqreturn_t intr(int irqno, void *dev_id)
1315 struct Scsi_Host *shpnt = dev_id;
1316 unsigned long flags;
1317 unsigned char rev, dmacntrl0;
1320 * Read a couple of registers that are known to not be all 1's. If
1321 * we read all 1's (-1), that means that either:
1323 * a. The host adapter chip has gone bad, and we cannot control it,
1325 * b. The host adapter is a PCMCIA card that has been ejected
1327 * In either case, we cannot do anything with the host adapter at
1328 * this point in time. So just ignore the interrupt and return.
1329 * In the latter case, the interrupt might actually be meant for
1330 * someone else sharing this IRQ, and that driver will handle it.
1333 dmacntrl0 = GETPORT(DMACNTRL0);
1334 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1337 if( TESTLO(DMASTAT, INTSTAT) )
1340 /* no more interrupts from the controller, while we're busy.
1341 INTEN is restored by the BH handler */
1342 CLRBITS(DMACNTRL0, INTEN);
1345 if( HOSTDATA(shpnt)->service==0 ) {
1346 HOSTDATA(shpnt)->service=1;
1348 /* Poke the BH handler */
1349 INIT_WORK(&aha152x_tq, run);
1350 schedule_work(&aha152x_tq);
1359 * - handle completition/disconnection/error of current command
1360 * - start selection for next command (if any)
1362 static void busfree_run(struct Scsi_Host *shpnt)
1364 unsigned long flags;
1365 #if defined(AHA152X_STAT)
1369 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1370 SETPORT(SXFRCTL0, CH1);
1372 SETPORT(SSTAT1, CLRBUSFREE);
1375 #if defined(AHA152X_STAT)
1378 CURRENT_SC->SCp.phase &= ~syncneg;
1380 if(CURRENT_SC->SCp.phase & completed) {
1381 /* target sent COMMAND COMPLETE */
1382 done(shpnt, CURRENT_SC->SCp.Status, DID_OK);
1384 } else if(CURRENT_SC->SCp.phase & aborted) {
1385 done(shpnt, CURRENT_SC->SCp.Status, DID_ABORT);
1387 } else if(CURRENT_SC->SCp.phase & resetted) {
1388 done(shpnt, CURRENT_SC->SCp.Status, DID_RESET);
1390 } else if(CURRENT_SC->SCp.phase & disconnected) {
1391 /* target sent DISCONNECT */
1392 #if defined(AHA152X_STAT)
1393 HOSTDATA(shpnt)->disconnections++;
1395 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1396 CURRENT_SC->SCp.phase |= 1 << 16;
1400 done(shpnt, SAM_STAT_GOOD, DID_ERROR);
1402 #if defined(AHA152X_STAT)
1404 HOSTDATA(shpnt)->busfree_without_old_command++;
1411 #if defined(AHA152X_STAT)
1415 if(DONE_SC->SCp.phase & check_condition) {
1416 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1417 struct aha152x_scdata *sc = SCDATA(cmd);
1419 scsi_eh_restore_cmnd(cmd, &sc->ses);
1421 cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1423 HOSTDATA(shpnt)->commands--;
1424 if (!HOSTDATA(shpnt)->commands)
1425 SETPORT(PORTA, 0); /* turn led off */
1426 } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1427 #if defined(AHA152X_STAT)
1428 HOSTDATA(shpnt)->busfree_with_check_condition++;
1431 if(!(DONE_SC->SCp.phase & not_issued)) {
1432 struct aha152x_scdata *sc;
1433 struct scsi_cmnd *ptr = DONE_SC;
1437 /* It was allocated in aha152x_internal_queue? */
1439 scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1442 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1447 if(DONE_SC && DONE_SC->scsi_done) {
1448 struct scsi_cmnd *ptr = DONE_SC;
1451 /* turn led off, when no commands are in the driver */
1452 HOSTDATA(shpnt)->commands--;
1453 if (!HOSTDATA(shpnt)->commands)
1454 SETPORT(PORTA, 0); /* turn led off */
1456 if(ptr->scsi_done != reset_done) {
1457 kfree(ptr->host_scribble);
1458 ptr->host_scribble=NULL;
1462 ptr->scsi_done(ptr);
1467 #if defined(AHA152X_STAT)
1469 HOSTDATA(shpnt)->busfree_without_done_command++;
1474 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1479 #if defined(AHA152X_STAT)
1482 CURRENT_SC->SCp.phase |= selecting;
1484 /* clear selection timeout */
1485 SETPORT(SSTAT1, SELTO);
1487 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1488 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1489 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1491 #if defined(AHA152X_STAT)
1492 HOSTDATA(shpnt)->busfree_without_new_command++;
1494 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1497 #if defined(AHA152X_STAT)
1499 HOSTDATA(shpnt)->busfree_without_any_action++;
1504 * Selection done (OUT)
1505 * - queue IDENTIFY message and SDTR to selected target for message out
1506 * (ATN asserted automagically via ENAUTOATNO in busfree())
1508 static void seldo_run(struct Scsi_Host *shpnt)
1510 SETPORT(SCSISIG, 0);
1511 SETPORT(SSTAT1, CLRBUSFREE);
1512 SETPORT(SSTAT1, CLRPHASECHG);
1514 CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1516 SETPORT(SCSISEQ, 0);
1518 if (TESTLO(SSTAT0, SELDO)) {
1519 scmd_printk(KERN_ERR, CURRENT_SC,
1520 "aha152x: passing bus free condition\n");
1521 done(shpnt, SAM_STAT_GOOD, DID_NO_CONNECT);
1525 SETPORT(SSTAT0, CLRSELDO);
1527 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1529 if (CURRENT_SC->SCp.phase & aborting) {
1531 } else if (CURRENT_SC->SCp.phase & resetting) {
1532 ADDMSGO(BUS_DEVICE_RESET);
1533 } else if (SYNCNEG==0 && SYNCHRONOUS) {
1534 CURRENT_SC->SCp.phase |= syncneg;
1535 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1536 SYNCNEG=1; /* negotiation in progress */
1544 * - return command to mid-level with failure cause
1547 static void selto_run(struct Scsi_Host *shpnt)
1549 SETPORT(SCSISEQ, 0);
1550 SETPORT(SSTAT1, CLRSELTIMO);
1555 CURRENT_SC->SCp.phase &= ~selecting;
1557 if (CURRENT_SC->SCp.phase & aborted)
1558 done(shpnt, SAM_STAT_GOOD, DID_ABORT);
1559 else if (TESTLO(SSTAT0, SELINGO))
1560 done(shpnt, SAM_STAT_GOOD, DID_BUS_BUSY);
1562 /* ARBITRATION won, but SELECTION failed */
1563 done(shpnt, SAM_STAT_GOOD, DID_NO_CONNECT);
1568 * - put current command back to issue queue
1569 * (reconnection of a disconnected nexus instead
1570 * of successful selection out)
1573 static void seldi_run(struct Scsi_Host *shpnt)
1577 unsigned long flags;
1579 SETPORT(SCSISIG, 0);
1580 SETPORT(SSTAT0, CLRSELDI);
1581 SETPORT(SSTAT1, CLRBUSFREE);
1582 SETPORT(SSTAT1, CLRPHASECHG);
1585 if(!(CURRENT_SC->SCp.phase & not_issued))
1586 scmd_printk(KERN_ERR, CURRENT_SC,
1587 "command should not have been issued yet\n");
1590 append_SC(&ISSUE_SC, CURRENT_SC);
1596 if (!DISCONNECTED_SC)
1601 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1604 shost_printk(KERN_INFO, shpnt,
1605 "target id unknown (%02x)\n", selid);
1609 for(target=7; !(selid & (1 << target)); target--)
1612 if(selid & ~(1 << target)) {
1613 shost_printk(KERN_INFO, shpnt,
1614 "multiple targets reconnected (%02x)\n", selid);
1618 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1619 SETPORT(SCSISEQ, 0);
1621 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1623 RECONN_TARGET=target;
1628 * - handle initial message after reconnection to identify
1629 * reconnecting nexus
1630 * - queue command on DISCONNECTED_SC on DISCONNECT message
1631 * - set completed flag on COMMAND COMPLETE
1632 * (other completition code moved to busfree_run)
1633 * - handle response to SDTR
1634 * - clear synchronous transfer agreements on BUS RESET
1636 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1639 static void msgi_run(struct Scsi_Host *shpnt)
1642 int sstat1 = GETPORT(SSTAT1);
1644 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1647 if (TESTLO(SSTAT0, SPIORDY))
1650 ADDMSGI(GETPORT(SCSIDAT));
1653 if(LASTSTATE!=seldi) {
1654 shost_printk(KERN_ERR, shpnt,
1655 "message in w/o current command"
1656 " not after reselection\n");
1660 * Handle reselection
1662 if(!(MSGI(0) & IDENTIFY_BASE)) {
1663 shost_printk(KERN_ERR, shpnt,
1664 "target didn't identify after reselection\n");
1668 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1672 shost_printk(KERN_ERR, shpnt,
1673 "no disconnected command"
1674 " for target %d/%d\n",
1675 RECONN_TARGET, MSGI(0) & 0x3f);
1679 CURRENT_SC->SCp.Message = MSGI(0);
1680 CURRENT_SC->SCp.phase &= ~disconnected;
1684 /* next message if any */
1688 CURRENT_SC->SCp.Message = MSGI(0);
1693 scmd_printk(KERN_WARNING, CURRENT_SC,
1694 "target was not allowed to disconnect\n");
1696 CURRENT_SC->SCp.phase |= disconnected;
1699 case COMMAND_COMPLETE:
1700 CURRENT_SC->SCp.phase |= completed;
1703 case MESSAGE_REJECT:
1705 scmd_printk(KERN_INFO, CURRENT_SC,
1706 "Synchronous Data Transfer Request"
1708 SYNCNEG=2; /* negotiation completed */
1710 scmd_printk(KERN_INFO, CURRENT_SC,
1711 "inbound message (MESSAGE REJECT)\n");
1717 case RESTORE_POINTERS:
1720 case EXTENDED_MESSAGE:
1721 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1722 /* not yet completed */
1732 scmd_printk(KERN_ERR, CURRENT_SC,
1733 "SDTR message length!=3\n");
1737 if (!HOSTDATA(shpnt)->synchronous)
1740 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1741 spi_print_msg(&MSGI(0));
1744 ticks = (MSGI(3) * 4 + 49) / 50;
1747 /* negotiation in progress */
1748 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1749 ADDMSGO(MESSAGE_REJECT);
1750 scmd_printk(KERN_INFO,
1752 "received Synchronous Data Transfer Request invalid - rejected\n");
1756 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1757 } else if (ticks <= 9 && MSGI(4) >= 1) {
1758 ADDMSGO(EXTENDED_MESSAGE);
1760 ADDMSGO(EXTENDED_SDTR);
1772 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1774 /* requested SDTR is too slow, do it asynchronously */
1775 scmd_printk(KERN_INFO,
1777 "Synchronous Data Transfer Request too slow - Rejecting\n");
1778 ADDMSGO(MESSAGE_REJECT);
1781 /* negotiation completed */
1787 case BUS_DEVICE_RESET:
1791 for(i=0; i<8; i++) {
1792 HOSTDATA(shpnt)->syncrate[i]=0;
1793 HOSTDATA(shpnt)->syncneg[i]=0;
1799 case EXTENDED_MODIFY_DATA_POINTER:
1800 case EXTENDED_EXTENDED_IDENTIFY:
1803 ADDMSGO(MESSAGE_REJECT);
1813 static void msgi_end(struct Scsi_Host *shpnt)
1816 scmd_printk(KERN_WARNING, CURRENT_SC,
1817 "target left before message completed (%d)\n",
1820 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE))
1821 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1828 static void msgo_init(struct Scsi_Host *shpnt)
1831 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
1832 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1834 scmd_printk(KERN_INFO, CURRENT_SC,
1835 "unexpected MESSAGE OUT phase; rejecting\n");
1836 ADDMSGO(MESSAGE_REJECT);
1846 static void msgo_run(struct Scsi_Host *shpnt)
1848 while(MSGO_I<MSGOLEN) {
1849 if (TESTLO(SSTAT0, SPIORDY))
1852 if (MSGO_I==MSGOLEN-1) {
1853 /* Leave MESSAGE OUT after transfer */
1854 SETPORT(SSTAT1, CLRATNO);
1858 if (MSGO(MSGO_I) & IDENTIFY_BASE)
1859 CURRENT_SC->SCp.phase |= identified;
1861 if (MSGO(MSGO_I)==ABORT)
1862 CURRENT_SC->SCp.phase |= aborted;
1864 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
1865 CURRENT_SC->SCp.phase |= resetted;
1867 SETPORT(SCSIDAT, MSGO(MSGO_I++));
1871 static void msgo_end(struct Scsi_Host *shpnt)
1873 if(MSGO_I<MSGOLEN) {
1874 scmd_printk(KERN_ERR, CURRENT_SC,
1875 "message sent incompletely (%d/%d)\n",
1878 scmd_printk(KERN_INFO, CURRENT_SC,
1879 "Synchronous Data Transfer Request was rejected\n");
1892 static void cmd_init(struct Scsi_Host *shpnt)
1894 if (CURRENT_SC->SCp.sent_command) {
1895 scmd_printk(KERN_ERR, CURRENT_SC,
1896 "command already sent\n");
1897 done(shpnt, SAM_STAT_GOOD, DID_ERROR);
1908 static void cmd_run(struct Scsi_Host *shpnt)
1910 while(CMD_I<CURRENT_SC->cmd_len) {
1911 if (TESTLO(SSTAT0, SPIORDY))
1914 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
1918 static void cmd_end(struct Scsi_Host *shpnt)
1920 if(CMD_I<CURRENT_SC->cmd_len)
1921 scmd_printk(KERN_ERR, CURRENT_SC,
1922 "command sent incompletely (%d/%d)\n",
1923 CMD_I, CURRENT_SC->cmd_len);
1925 CURRENT_SC->SCp.sent_command++;
1932 static void status_run(struct Scsi_Host *shpnt)
1934 if (TESTLO(SSTAT0, SPIORDY))
1937 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
1945 static void datai_init(struct Scsi_Host *shpnt)
1947 SETPORT(DMACNTRL0, RSTFIFO);
1948 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
1950 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
1951 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
1953 SETPORT(SIMODE0, 0);
1954 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
1959 static void datai_run(struct Scsi_Host *shpnt)
1961 unsigned long the_time;
1962 int fifodata, data_count;
1965 * loop while the phase persists or the fifos are not empty
1968 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
1969 /* FIXME: maybe this should be done by setting up
1970 * STCNT to trigger ENSWRAP interrupt, instead of
1971 * polling for DFIFOFULL
1973 the_time=jiffies + 100*HZ;
1974 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
1977 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
1978 scmd_printk(KERN_ERR, CURRENT_SC, "datai timeout\n");
1982 if(TESTHI(DMASTAT, DFIFOFULL)) {
1985 the_time=jiffies + 100*HZ;
1986 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
1989 if(TESTLO(SSTAT2, SEMPTY)) {
1990 scmd_printk(KERN_ERR, CURRENT_SC,
1991 "datai sempty timeout");
1995 fifodata = GETPORT(FIFOSTAT);
1998 if(CURRENT_SC->SCp.this_residual>0) {
1999 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2000 data_count = fifodata > CURRENT_SC->SCp.this_residual ?
2001 CURRENT_SC->SCp.this_residual :
2003 fifodata -= data_count;
2005 if (data_count & 1) {
2006 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2007 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2008 CURRENT_SC->SCp.this_residual--;
2010 SETPORT(DMACNTRL0, ENDMA);
2013 if (data_count > 1) {
2015 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2016 CURRENT_SC->SCp.ptr += 2 * data_count;
2017 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2018 DATA_LEN += 2 * data_count;
2021 if (CURRENT_SC->SCp.this_residual == 0 &&
2022 !sg_is_last(CURRENT_SC->SCp.buffer)) {
2023 /* advance to next buffer */
2024 CURRENT_SC->SCp.buffer = sg_next(CURRENT_SC->SCp.buffer);
2025 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2026 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2029 } else if (fifodata > 0) {
2030 scmd_printk(KERN_ERR, CURRENT_SC,
2031 "no buffers left for %d(%d) bytes"
2032 " (data overrun!?)\n",
2033 fifodata, GETPORT(FIFOSTAT));
2034 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2040 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2044 if(TESTLO(DMASTAT, INTSTAT) ||
2045 TESTLO(DMASTAT, DFIFOEMP) ||
2046 TESTLO(SSTAT2, SEMPTY) ||
2047 GETPORT(FIFOSTAT)>0) {
2049 * something went wrong, if there's something left in the fifos
2050 * or the phase didn't change
2052 scmd_printk(KERN_ERR, CURRENT_SC,
2053 "fifos should be empty and phase should have changed\n");
2056 if(DATA_LEN!=GETSTCNT()) {
2057 scmd_printk(KERN_ERR, CURRENT_SC,
2058 "manual transfer count differs from automatic "
2059 "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2060 DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
2066 static void datai_end(struct Scsi_Host *shpnt)
2068 CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2070 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2071 SETPORT(DMACNTRL0, 0);
2078 static void datao_init(struct Scsi_Host *shpnt)
2080 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2081 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2083 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2084 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2086 SETPORT(SIMODE0, 0);
2087 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2089 DATA_LEN = scsi_get_resid(CURRENT_SC);
2092 static void datao_run(struct Scsi_Host *shpnt)
2094 unsigned long the_time;
2097 /* until phase changes or all data sent */
2098 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2100 if(data_count > CURRENT_SC->SCp.this_residual)
2101 data_count=CURRENT_SC->SCp.this_residual;
2103 if(TESTLO(DMASTAT, DFIFOEMP)) {
2104 scmd_printk(KERN_ERR, CURRENT_SC,
2105 "datao fifo not empty (%d)",
2110 if(data_count & 1) {
2111 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2112 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2113 CURRENT_SC->SCp.this_residual--;
2114 CMD_INC_RESID(CURRENT_SC, -1);
2115 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2118 if(data_count > 1) {
2120 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2121 CURRENT_SC->SCp.ptr += 2 * data_count;
2122 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2123 CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2126 if (CURRENT_SC->SCp.this_residual == 0 &&
2127 !sg_is_last(CURRENT_SC->SCp.buffer)) {
2128 /* advance to next buffer */
2129 CURRENT_SC->SCp.buffer = sg_next(CURRENT_SC->SCp.buffer);
2130 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2131 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2134 the_time=jiffies + 100*HZ;
2135 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2138 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2139 scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
2145 static void datao_end(struct Scsi_Host *shpnt)
2147 if(TESTLO(DMASTAT, DFIFOEMP)) {
2148 u32 datao_cnt = GETSTCNT();
2149 int datao_out = DATA_LEN - scsi_get_resid(CURRENT_SC);
2151 struct scatterlist *sg = scsi_sglist(CURRENT_SC);
2153 CMD_INC_RESID(CURRENT_SC, datao_out - datao_cnt);
2155 done = scsi_bufflen(CURRENT_SC) - scsi_get_resid(CURRENT_SC);
2156 /* Locate the first SG entry not yet sent */
2157 while (done > 0 && !sg_is_last(sg)) {
2158 if (done < sg->length)
2164 CURRENT_SC->SCp.buffer = sg;
2165 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) + done;
2166 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length -
2170 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2171 SETPORT(SXFRCTL0, CH1);
2173 SETPORT(DMACNTRL0, 0);
2177 * figure out what state we're in
2180 static int update_state(struct Scsi_Host *shpnt)
2183 unsigned int stat0 = GETPORT(SSTAT0);
2184 unsigned int stat1 = GETPORT(SSTAT1);
2189 if(stat1 & SCSIRSTI) {
2192 SETPORT(SSTAT1,SCSIRSTI);
2193 } else if (stat0 & SELDI && PREVSTATE == busfree) {
2195 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2197 } else if(stat1 & SELTO) {
2199 } else if(stat1 & BUSFREE) {
2201 SETPORT(SSTAT1,BUSFREE);
2202 } else if(stat1 & SCSIPERR) {
2204 SETPORT(SSTAT1,SCSIPERR);
2205 } else if(stat1 & REQINIT) {
2206 switch(GETPORT(SCSISIG) & P_MASK) {
2207 case P_MSGI: STATE=msgi; break;
2208 case P_MSGO: STATE=msgo; break;
2209 case P_DATAO: STATE=datao; break;
2210 case P_DATAI: STATE=datai; break;
2211 case P_STATUS: STATE=status; break;
2212 case P_CMD: STATE=cmd; break;
2217 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2218 scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
2221 if(STATE!=PREVSTATE) {
2222 LASTSTATE=PREVSTATE;
2229 * handle parity error
2231 * FIXME: in which phase?
2234 static void parerr_run(struct Scsi_Host *shpnt)
2236 scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
2237 done(shpnt, SAM_STAT_GOOD, DID_PARITY);
2244 static void rsti_run(struct Scsi_Host *shpnt)
2246 struct scsi_cmnd *ptr;
2248 shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
2250 ptr=DISCONNECTED_SC;
2252 struct scsi_cmnd *next = SCNEXT(ptr);
2254 if (!ptr->device->soft_reset) {
2255 remove_SC(&DISCONNECTED_SC, ptr);
2257 kfree(ptr->host_scribble);
2258 ptr->host_scribble=NULL;
2260 set_host_byte(ptr, DID_RESET);
2261 ptr->scsi_done(ptr);
2267 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2268 done(shpnt, SAM_STAT_GOOD, DID_RESET);
2273 * bottom-half handler
2276 static void is_complete(struct Scsi_Host *shpnt)
2279 unsigned long flags;
2287 if( HOSTDATA(shpnt)->service==0 ) {
2292 HOSTDATA(shpnt)->service = 0;
2294 if(HOSTDATA(shpnt)->in_intr) {
2296 /* aha152x_error never returns.. */
2297 aha152x_error(shpnt, "bottom-half already running!?");
2299 HOSTDATA(shpnt)->in_intr++;
2302 * loop while there are interrupt conditions pending
2306 unsigned long start = jiffies;
2309 dataphase=update_state(shpnt);
2312 * end previous state
2315 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2316 states[PREVSTATE].end(shpnt);
2319 * disable SPIO mode if previous phase used it
2320 * and this one doesn't
2323 if(states[PREVSTATE].spio && !states[STATE].spio) {
2324 SETPORT(SXFRCTL0, CH1);
2325 SETPORT(DMACNTRL0, 0);
2327 CURRENT_SC->SCp.phase &= ~spiordy;
2331 * accept current dataphase phase
2335 SETPORT(SSTAT0, REQINIT);
2336 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2337 SETPORT(SSTAT1, PHASECHG);
2341 * enable SPIO mode if previous didn't use it
2345 if(!states[PREVSTATE].spio && states[STATE].spio) {
2346 SETPORT(DMACNTRL0, 0);
2347 SETPORT(SXFRCTL0, CH1|SPIOEN);
2349 CURRENT_SC->SCp.phase |= spiordy;
2353 * initialize for new state
2356 if(PREVSTATE!=STATE && states[STATE].init)
2357 states[STATE].init(shpnt);
2360 * handle current state
2363 if(states[STATE].run)
2364 states[STATE].run(shpnt);
2366 scmd_printk(KERN_ERR, CURRENT_SC,
2367 "unexpected state (%x)\n", STATE);
2370 * setup controller to interrupt on
2371 * the next expected condition and
2372 * loop if it's already there
2376 pending=setup_expected_interrupts(shpnt);
2377 #if defined(AHA152X_STAT)
2378 HOSTDATA(shpnt)->count[STATE]++;
2379 if(PREVSTATE!=STATE)
2380 HOSTDATA(shpnt)->count_trans[STATE]++;
2381 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2387 * enable interrupts and leave bottom-half
2390 HOSTDATA(shpnt)->in_intr--;
2391 SETBITS(DMACNTRL0, INTEN);
2397 * Dump the current driver status and panic
2399 static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2401 shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
2403 panic("aha152x panic\n");
2407 * display enabled interrupts
2409 static void disp_enintr(struct Scsi_Host *shpnt)
2413 s0 = GETPORT(SIMODE0);
2414 s1 = GETPORT(SIMODE1);
2416 shost_printk(KERN_DEBUG, shpnt,
2417 "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2418 (s0 & ENSELDO) ? "ENSELDO " : "",
2419 (s0 & ENSELDI) ? "ENSELDI " : "",
2420 (s0 & ENSELINGO) ? "ENSELINGO " : "",
2421 (s0 & ENSWRAP) ? "ENSWRAP " : "",
2422 (s0 & ENSDONE) ? "ENSDONE " : "",
2423 (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
2424 (s0 & ENDMADONE) ? "ENDMADONE " : "",
2425 (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
2426 (s1 & ENATNTARG) ? "ENATNTARG " : "",
2427 (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
2428 (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
2429 (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
2430 (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
2431 (s1 & ENREQINIT) ? "ENREQINIT " : "");
2435 * Show the command data of a command
2437 static void show_command(struct scsi_cmnd *ptr)
2439 scsi_print_command(ptr);
2440 scmd_printk(KERN_DEBUG, ptr,
2441 "request_bufflen=%d; resid=%d; "
2442 "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
2443 scsi_bufflen(ptr), scsi_get_resid(ptr),
2444 (ptr->SCp.phase & not_issued) ? "not issued|" : "",
2445 (ptr->SCp.phase & selecting) ? "selecting|" : "",
2446 (ptr->SCp.phase & identified) ? "identified|" : "",
2447 (ptr->SCp.phase & disconnected) ? "disconnected|" : "",
2448 (ptr->SCp.phase & completed) ? "completed|" : "",
2449 (ptr->SCp.phase & spiordy) ? "spiordy|" : "",
2450 (ptr->SCp.phase & syncneg) ? "syncneg|" : "",
2451 (ptr->SCp.phase & aborted) ? "aborted|" : "",
2452 (ptr->SCp.phase & resetted) ? "resetted|" : "",
2453 (SCDATA(ptr)) ? SCNEXT(ptr) : NULL);
2457 * Dump the queued data
2459 static void show_queues(struct Scsi_Host *shpnt)
2461 struct scsi_cmnd *ptr;
2462 unsigned long flags;
2465 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2466 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2470 printk(KERN_DEBUG "current_SC:\n");
2472 show_command(CURRENT_SC);
2474 printk(KERN_DEBUG "none\n");
2476 printk(KERN_DEBUG "disconnected_SC:\n");
2477 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2483 static void get_command(struct seq_file *m, struct scsi_cmnd * ptr)
2487 seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
2488 ptr, ptr->device->id, (u8)ptr->device->lun);
2490 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2491 seq_printf(m, "0x%02x ", ptr->cmnd[i]);
2493 seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
2494 scsi_get_resid(ptr), ptr->SCp.this_residual,
2495 sg_nents(ptr->SCp.buffer) - 1);
2497 if (ptr->SCp.phase & not_issued)
2498 seq_puts(m, "not issued|");
2499 if (ptr->SCp.phase & selecting)
2500 seq_puts(m, "selecting|");
2501 if (ptr->SCp.phase & disconnected)
2502 seq_puts(m, "disconnected|");
2503 if (ptr->SCp.phase & aborted)
2504 seq_puts(m, "aborted|");
2505 if (ptr->SCp.phase & identified)
2506 seq_puts(m, "identified|");
2507 if (ptr->SCp.phase & completed)
2508 seq_puts(m, "completed|");
2509 if (ptr->SCp.phase & spiordy)
2510 seq_puts(m, "spiordy|");
2511 if (ptr->SCp.phase & syncneg)
2512 seq_puts(m, "syncneg|");
2513 seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
2516 static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
2520 seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
2522 s = GETPORT(SCSISEQ);
2523 seq_puts(m, "SCSISEQ( ");
2525 seq_puts(m, "TARGET MODE ");
2527 seq_puts(m, "SELO ");
2529 seq_puts(m, "SELI ");
2531 seq_puts(m, "RESELI ");
2533 seq_puts(m, "AUTOATNO ");
2535 seq_puts(m, "AUTOATNI ");
2537 seq_puts(m, "AUTOATNP ");
2539 seq_puts(m, "SCSIRSTO ");
2542 seq_puts(m, " SCSISIG(");
2543 s = GETPORT(SCSISIG);
2544 switch (s & P_MASK) {
2546 seq_puts(m, "DATA OUT");
2549 seq_puts(m, "DATA IN");
2552 seq_puts(m, "COMMAND");
2555 seq_puts(m, "STATUS");
2558 seq_puts(m, "MESSAGE OUT");
2561 seq_puts(m, "MESSAGE IN");
2564 seq_puts(m, "*invalid*");
2570 seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2572 seq_puts(m, "SSTAT( ");
2573 s = GETPORT(SSTAT0);
2575 seq_puts(m, "TARGET ");
2577 seq_puts(m, "SELDO ");
2579 seq_puts(m, "SELDI ");
2581 seq_puts(m, "SELINGO ");
2583 seq_puts(m, "SWRAP ");
2585 seq_puts(m, "SDONE ");
2587 seq_puts(m, "SPIORDY ");
2589 seq_puts(m, "DMADONE ");
2591 s = GETPORT(SSTAT1);
2593 seq_puts(m, "SELTO ");
2595 seq_puts(m, "ATNTARG ");
2597 seq_puts(m, "SCSIRSTI ");
2599 seq_puts(m, "PHASEMIS ");
2601 seq_puts(m, "BUSFREE ");
2603 seq_puts(m, "SCSIPERR ");
2605 seq_puts(m, "PHASECHG ");
2607 seq_puts(m, "REQINIT ");
2611 seq_puts(m, "SSTAT( ");
2613 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2616 seq_puts(m, "TARGET ");
2618 seq_puts(m, "SELDO ");
2620 seq_puts(m, "SELDI ");
2622 seq_puts(m, "SELINGO ");
2624 seq_puts(m, "SWRAP ");
2626 seq_puts(m, "SDONE ");
2628 seq_puts(m, "SPIORDY ");
2630 seq_puts(m, "DMADONE ");
2632 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2635 seq_puts(m, "SELTO ");
2637 seq_puts(m, "ATNTARG ");
2639 seq_puts(m, "SCSIRSTI ");
2641 seq_puts(m, "PHASEMIS ");
2643 seq_puts(m, "BUSFREE ");
2645 seq_puts(m, "SCSIPERR ");
2647 seq_puts(m, "PHASECHG ");
2649 seq_puts(m, "REQINIT ");
2652 seq_puts(m, "SXFRCTL0( ");
2654 s = GETPORT(SXFRCTL0);
2656 seq_puts(m, "SCSIEN ");
2658 seq_puts(m, "DMAEN ");
2660 seq_puts(m, "CH1 ");
2662 seq_puts(m, "CLRSTCNT ");
2664 seq_puts(m, "SPIOEN ");
2666 seq_puts(m, "CLRCH1 ");
2669 seq_puts(m, "SIGNAL( ");
2671 s = GETPORT(SCSISIG);
2673 seq_puts(m, "ATNI ");
2675 seq_puts(m, "SELI ");
2677 seq_puts(m, "BSYI ");
2679 seq_puts(m, "REQI ");
2681 seq_puts(m, "ACKI ");
2684 seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
2686 seq_printf(m, "STCNT(%d), ", GETSTCNT());
2688 seq_puts(m, "SSTAT2( ");
2690 s = GETPORT(SSTAT2);
2692 seq_puts(m, "SOFFSET ");
2694 seq_puts(m, "SEMPTY ");
2696 seq_puts(m, "SFULL ");
2697 seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
2699 s = GETPORT(SSTAT3);
2700 seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2702 seq_puts(m, "SSTAT4( ");
2703 s = GETPORT(SSTAT4);
2705 seq_puts(m, "SYNCERR ");
2707 seq_puts(m, "FWERR ");
2709 seq_puts(m, "FRERR ");
2712 seq_puts(m, "DMACNTRL0( ");
2713 s = GETPORT(DMACNTRL0);
2714 seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
2715 seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
2716 seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
2718 seq_puts(m, "ENDMA ");
2720 seq_puts(m, "INTEN ");
2722 seq_puts(m, "RSTFIFO ");
2724 seq_puts(m, "SWINT ");
2727 seq_puts(m, "DMASTAT( ");
2728 s = GETPORT(DMASTAT);
2730 seq_puts(m, "ATDONE ");
2732 seq_puts(m, "WORDRDY ");
2734 seq_puts(m, "DFIFOFULL ");
2736 seq_puts(m, "DFIFOEMP ");
2739 seq_puts(m, "enabled interrupts( ");
2741 s = GETPORT(SIMODE0);
2743 seq_puts(m, "ENSELDO ");
2745 seq_puts(m, "ENSELDI ");
2747 seq_puts(m, "ENSELINGO ");
2749 seq_puts(m, "ENSWRAP ");
2751 seq_puts(m, "ENSDONE ");
2753 seq_puts(m, "ENSPIORDY ");
2755 seq_puts(m, "ENDMADONE ");
2757 s = GETPORT(SIMODE1);
2759 seq_puts(m, "ENSELTIMO ");
2761 seq_puts(m, "ENATNTARG ");
2763 seq_puts(m, "ENPHASEMIS ");
2765 seq_puts(m, "ENBUSFREE ");
2767 seq_puts(m, "ENSCSIPERR ");
2769 seq_puts(m, "ENPHASECHG ");
2771 seq_puts(m, "ENREQINIT ");
2775 static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
2777 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
2780 #if defined(AHA152X_STAT)
2781 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
2784 HOSTDATA(shpnt)->total_commands=0;
2785 HOSTDATA(shpnt)->disconnections=0;
2786 HOSTDATA(shpnt)->busfree_without_any_action=0;
2787 HOSTDATA(shpnt)->busfree_without_old_command=0;
2788 HOSTDATA(shpnt)->busfree_without_new_command=0;
2789 HOSTDATA(shpnt)->busfree_without_done_command=0;
2790 HOSTDATA(shpnt)->busfree_with_check_condition=0;
2791 for (i = idle; i<maxstate; i++) {
2792 HOSTDATA(shpnt)->count[i]=0;
2793 HOSTDATA(shpnt)->count_trans[i]=0;
2794 HOSTDATA(shpnt)->time[i]=0;
2797 shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
2809 static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
2812 struct scsi_cmnd *ptr;
2813 unsigned long flags;
2815 seq_puts(m, AHA152X_REVID "\n");
2817 seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
2818 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
2819 seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
2820 seq_printf(m, "disconnection/reconnection %s\n",
2821 RECONNECT ? "enabled" : "disabled");
2822 seq_printf(m, "parity checking %s\n",
2823 PARITY ? "enabled" : "disabled");
2824 seq_printf(m, "synchronous transfers %s\n",
2825 SYNCHRONOUS ? "enabled" : "disabled");
2826 seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
2829 seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
2830 for (i = 0; i < 8; i++)
2831 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
2832 seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
2834 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
2835 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
2836 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
2838 seq_puts(m, "\nqueue status:\n");
2841 seq_puts(m, "not yet issued commands:\n");
2842 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2843 get_command(m, ptr);
2845 seq_puts(m, "no not yet issued commands\n");
2849 seq_puts(m, "current command:\n");
2850 get_command(m, CURRENT_SC);
2852 seq_puts(m, "no current command\n");
2854 if (DISCONNECTED_SC) {
2855 seq_puts(m, "disconnected commands:\n");
2856 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
2857 get_command(m, ptr);
2859 seq_puts(m, "no disconnected commands\n");
2861 get_ports(m, shpnt);
2863 #if defined(AHA152X_STAT)
2864 seq_printf(m, "statistics:\n"
2865 "total commands: %d\n"
2866 "disconnections: %d\n"
2867 "busfree with check condition: %d\n"
2868 "busfree without old command: %d\n"
2869 "busfree without new command: %d\n"
2870 "busfree without done command: %d\n"
2871 "busfree without any action: %d\n"
2876 HOSTDATA(shpnt)->total_commands,
2877 HOSTDATA(shpnt)->disconnections,
2878 HOSTDATA(shpnt)->busfree_with_check_condition,
2879 HOSTDATA(shpnt)->busfree_without_old_command,
2880 HOSTDATA(shpnt)->busfree_without_new_command,
2881 HOSTDATA(shpnt)->busfree_without_done_command,
2882 HOSTDATA(shpnt)->busfree_without_any_action);
2883 for(i=0; i<maxstate; i++) {
2884 seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
2886 HOSTDATA(shpnt)->count_trans[i],
2887 HOSTDATA(shpnt)->count[i],
2888 HOSTDATA(shpnt)->time[i]);
2894 static int aha152x_adjust_queue(struct scsi_device *device)
2896 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
2900 static struct scsi_host_template aha152x_driver_template = {
2901 .module = THIS_MODULE,
2902 .name = AHA152X_REVID,
2903 .proc_name = "aha152x",
2904 .show_info = aha152x_show_info,
2905 .write_info = aha152x_set_info,
2906 .queuecommand = aha152x_queue,
2907 .eh_abort_handler = aha152x_abort,
2908 .eh_device_reset_handler = aha152x_device_reset,
2909 .eh_bus_reset_handler = aha152x_bus_reset,
2910 .bios_param = aha152x_biosparam,
2913 .sg_tablesize = SG_ALL,
2914 .dma_boundary = PAGE_SIZE - 1,
2915 .slave_alloc = aha152x_adjust_queue,
2918 #if !defined(AHA152X_PCMCIA)
2919 static int setup_count;
2920 static struct aha152x_setup setup[2];
2922 /* possible i/o addresses for the AIC-6260; default first */
2923 static unsigned short ports[] = { 0x340, 0x140 };
2925 #if !defined(SKIP_BIOSTEST)
2926 /* possible locations for the Adaptec BIOS; defaults first */
2927 static unsigned int addresses[] =
2929 0xdc000, /* default first */
2936 0xeb800, /* VTech Platinum SMP */
2940 /* signatures for various AIC-6[23]60 based controllers.
2941 The point in detecting signatures is to avoid useless and maybe
2942 harmful probes on ports. I'm not sure that all listed boards pass
2943 auto-configuration. For those which fail the BIOS signature is
2944 obsolete, because user intervention to supply the configuration is
2945 needed anyway. May be an information whether or not the BIOS supports
2946 extended translation could be also useful here. */
2947 static struct signature {
2948 unsigned char *signature;
2953 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
2955 { "Adaptec AHA-1520B", 0x000b, 17 },
2956 /* Adaptec 152x rev B */
2957 { "Adaptec AHA-1520B", 0x0026, 17 },
2958 /* Iomega Jaz Jet ISA (AIC6370Q) */
2959 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
2960 /* on-board controller */
2961 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
2962 /* on-board controller */
2963 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
2964 /* on-board controller */
2965 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
2966 /* on-board controller */
2967 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
2968 /* ScsiPro-Controller */
2969 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
2970 /* Gigabyte Local-Bus-SCSI */
2971 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
2973 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
2974 /* IBM Thinkpad Dock II */
2975 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
2976 /* IBM Thinkpad Dock II SCSI */
2977 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
2978 /* DTC 3520A ISA SCSI */
2980 #endif /* !SKIP_BIOSTEST */
2983 * Test, if port_base is valid.
2986 static int aha152x_porttest(int io_port)
2990 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
2991 for (i = 0; i < 16; i++)
2992 SETPORT(io_port + O_STACK, i);
2994 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
2995 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3001 static int tc1550_porttest(int io_port)
3005 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3006 for (i = 0; i < 16; i++)
3007 SETPORT(io_port + O_STACK, i);
3009 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3010 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3017 static int checksetup(struct aha152x_setup *setup)
3020 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3023 if (i == ARRAY_SIZE(ports))
3026 if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3027 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3031 if( aha152x_porttest(setup->io_port) ) {
3033 } else if( tc1550_porttest(setup->io_port) ) {
3036 release_region(setup->io_port, IO_RANGE);
3040 release_region(setup->io_port, IO_RANGE);
3042 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3045 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3048 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3051 if ((setup->parity < 0) || (setup->parity > 1))
3054 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3057 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3065 static int __init aha152x_init(void)
3068 #if defined(AUTOCONF)
3069 aha152x_config conf;
3072 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3075 if ( setup_count ) {
3076 printk(KERN_INFO "aha152x: processing commandline: ");
3078 for (i = 0; i<setup_count; i++) {
3079 if (!checksetup(&setup[i])) {
3080 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3081 printk(KERN_ERR "aha152x: invalid line\n");
3088 if (setup_count < ARRAY_SIZE(setup)) {
3089 struct aha152x_setup override = SETUP0;
3091 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3092 if (!checksetup(&override)) {
3093 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3099 override.synchronous,
3101 override.ext_trans);
3103 setup[setup_count++] = override;
3109 if (setup_count < ARRAY_SIZE(setup)) {
3110 struct aha152x_setup override = SETUP1;
3112 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3113 if (!checksetup(&override)) {
3114 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3120 override.synchronous,
3122 override.ext_trans);
3124 setup[setup_count++] = override;
3130 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3132 setup[setup_count].conf = "";
3133 setup[setup_count].io_port = aha152x[0];
3134 setup[setup_count].irq = aha152x[1];
3135 setup[setup_count].scsiid = aha152x[2];
3136 setup[setup_count].reconnect = aha152x[3];
3137 setup[setup_count].parity = aha152x[4];
3138 setup[setup_count].synchronous = aha152x[5];
3139 setup[setup_count].delay = aha152x[6];
3140 setup[setup_count].ext_trans = aha152x[7];
3141 } else if (io[0] != 0 || irq[0] != 0) {
3142 if(io[0]!=0) setup[setup_count].io_port = io[0];
3143 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3145 setup[setup_count].scsiid = scsiid[0];
3146 setup[setup_count].reconnect = reconnect[0];
3147 setup[setup_count].parity = parity[0];
3148 setup[setup_count].synchronous = sync[0];
3149 setup[setup_count].delay = delay[0];
3150 setup[setup_count].ext_trans = exttrans[0];
3153 if (checksetup(&setup[setup_count]))
3156 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",
3157 setup[setup_count].io_port,
3158 setup[setup_count].irq,
3159 setup[setup_count].scsiid,
3160 setup[setup_count].reconnect,
3161 setup[setup_count].parity,
3162 setup[setup_count].synchronous,
3163 setup[setup_count].delay,
3164 setup[setup_count].ext_trans);
3167 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3168 if(aha152x1[0]!=0) {
3169 setup[setup_count].conf = "";
3170 setup[setup_count].io_port = aha152x1[0];
3171 setup[setup_count].irq = aha152x1[1];
3172 setup[setup_count].scsiid = aha152x1[2];
3173 setup[setup_count].reconnect = aha152x1[3];
3174 setup[setup_count].parity = aha152x1[4];
3175 setup[setup_count].synchronous = aha152x1[5];
3176 setup[setup_count].delay = aha152x1[6];
3177 setup[setup_count].ext_trans = aha152x1[7];
3178 } else if (io[1] != 0 || irq[1] != 0) {
3179 if(io[1]!=0) setup[setup_count].io_port = io[1];
3180 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3182 setup[setup_count].scsiid = scsiid[1];
3183 setup[setup_count].reconnect = reconnect[1];
3184 setup[setup_count].parity = parity[1];
3185 setup[setup_count].synchronous = sync[1];
3186 setup[setup_count].delay = delay[1];
3187 setup[setup_count].ext_trans = exttrans[1];
3189 if (checksetup(&setup[setup_count]))
3192 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",
3193 setup[setup_count].io_port,
3194 setup[setup_count].irq,
3195 setup[setup_count].scsiid,
3196 setup[setup_count].reconnect,
3197 setup[setup_count].parity,
3198 setup[setup_count].synchronous,
3199 setup[setup_count].delay,
3200 setup[setup_count].ext_trans);
3205 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3206 while ( setup_count<ARRAY_SIZE(setup) &&
3207 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3208 if (pnp_device_attach(dev) < 0)
3211 if (pnp_activate_dev(dev) < 0) {
3212 pnp_device_detach(dev);
3216 if (!pnp_port_valid(dev, 0)) {
3217 pnp_device_detach(dev);
3221 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3222 pnp_device_detach(dev);
3226 setup[setup_count].io_port = pnp_port_start(dev, 0);
3227 setup[setup_count].irq = pnp_irq(dev, 0);
3228 setup[setup_count].scsiid = 7;
3229 setup[setup_count].reconnect = 1;
3230 setup[setup_count].parity = 1;
3231 setup[setup_count].synchronous = 1;
3232 setup[setup_count].delay = DELAY_DEFAULT;
3233 setup[setup_count].ext_trans = 0;
3234 #if defined(__ISAPNP__)
3235 pnpdev[setup_count] = dev;
3238 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3239 setup[setup_count].io_port, setup[setup_count].irq);
3245 #if defined(AUTOCONF)
3246 if (setup_count<ARRAY_SIZE(setup)) {
3247 #if !defined(SKIP_BIOSTEST)
3249 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3250 void __iomem *p = ioremap(addresses[i], 0x4000);
3253 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3254 ok = check_signature(p + signatures[j].sig_offset,
3255 signatures[j].signature, signatures[j].sig_length);
3258 if (!ok && setup_count == 0)
3261 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3263 printk(KERN_INFO "aha152x: ");
3264 #endif /* !SKIP_BIOSTEST */
3267 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3268 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3271 if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3272 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3276 if (aha152x_porttest(ports[i])) {
3277 setup[setup_count].tc1550 = 0;
3280 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3281 } else if (tc1550_porttest(ports[i])) {
3282 setup[setup_count].tc1550 = 1;
3285 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3287 release_region(ports[i], IO_RANGE);
3291 release_region(ports[i], IO_RANGE);
3294 setup[setup_count].io_port = ports[i];
3295 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3296 setup[setup_count].scsiid = conf.cf_id;
3297 setup[setup_count].reconnect = conf.cf_tardisc;
3298 setup[setup_count].parity = !conf.cf_parity;
3299 setup[setup_count].synchronous = conf.cf_syncneg;
3300 setup[setup_count].delay = DELAY_DEFAULT;
3301 setup[setup_count].ext_trans = 0;
3307 printk("auto configuration: ok, ");
3311 printk("%d controller(s) configured\n", setup_count);
3313 for (i=0; i<setup_count; i++) {
3314 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3315 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3318 release_region(setup[i].io_port, IO_RANGE);
3319 #if defined(__ISAPNP__)
3320 } else if( pnpdev[i] ) {
3321 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3326 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3329 #if defined(__ISAPNP__)
3331 pnp_device_detach(pnpdev[i]);
3338 static void __exit aha152x_exit(void)
3340 struct aha152x_hostdata *hd, *tmp;
3342 list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3343 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3345 aha152x_release(shost);
3349 module_init(aha152x_init);
3350 module_exit(aha152x_exit);
3352 #if !defined(MODULE)
3353 static int __init aha152x_setup(char *str)
3357 get_options(str, ARRAY_SIZE(ints), ints);
3359 if(setup_count>=ARRAY_SIZE(setup)) {
3360 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3364 setup[setup_count].conf = str;
3365 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3366 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3367 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3368 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3369 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3370 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3371 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3372 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3374 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3375 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3381 __setup("aha152x=", aha152x_setup);
3384 #endif /* !AHA152X_PCMCIA */