Loading...
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
5 *
6 * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
7 *
8 * $Log: aha152x.c,v $
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
16 *
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
23 *
24 * Revision 2.5 2002/04/14 11:24:53 fischer
25 * - isapnp support
26 * - abort fixed
27 * - 2.5 support
28 *
29 * Revision 2.4 2000/12/16 12:53:56 fischer
30 * - allow REQUEST SENSE to be queued
31 * - handle shared PCI interrupts
32 *
33 * Revision 2.3 2000/11/04 16:40:26 fischer
34 * - handle data overruns
35 * - extend timeout for data phases
36 *
37 * Revision 2.2 2000/08/08 19:54:53 fischer
38 * - minor changes
39 *
40 * Revision 2.1 2000/05/17 16:23:17 fischer
41 * - signature update
42 * - fix for data out w/o scatter gather
43 *
44 * Revision 2.0 1999/12/25 15:07:32 fischer
45 * - interrupt routine completly reworked
46 * - basic support for new eh code
47 *
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
53 *
54 * Revision 1.20 1999/11/07 18:37:31 fischer
55 * - synchronous operation works
56 * - resid support for sg driver
57 *
58 * Revision 1.19 1999/11/02 22:39:59 fischer
59 * - moved leading comments to README.aha152x
60 * - new additional module parameters
61 * - updates for 2.3
62 * - support for the Tripace TC1550 controller
63 * - interrupt handling changed
64 *
65 * Revision 1.18 1996/09/07 20:10:40 fischer
66 * - fixed can_queue handling (multiple outstanding commands working again)
67 *
68 * Revision 1.17 1996/08/17 16:05:14 fischer
69 * - biosparam improved
70 * - interrupt verification
71 * - updated documentation
72 * - cleanups
73 *
74 * Revision 1.16 1996/06/09 00:04:56 root
75 * - added configuration symbols for insmod (aha152x/aha152x1)
76 *
77 * Revision 1.15 1996/04/30 14:52:06 fischer
78 * - proc info fixed
79 * - support for extended translation for >1GB disks
80 *
81 * Revision 1.14 1996/01/17 15:11:20 fischer
82 * - fixed lockup in MESSAGE IN phase after reconnection
83 *
84 * Revision 1.13 1996/01/09 02:15:53 fischer
85 * - some cleanups
86 * - moved request_irq behind controller initialization
87 * (to avoid spurious interrupts)
88 *
89 * Revision 1.12 1995/12/16 12:26:07 fischer
90 * - barrier()s added
91 * - configurable RESET delay added
92 *
93 * Revision 1.11 1995/12/06 21:18:35 fischer
94 * - some minor updates
95 *
96 * Revision 1.10 1995/07/22 19:18:45 fischer
97 * - support for 2 controllers
98 * - started synchronous data transfers (not working yet)
99 *
100 * Revision 1.9 1995/03/18 09:20:24 root
101 * - patches for PCMCIA and modules
102 *
103 * Revision 1.8 1995/01/21 22:07:19 root
104 * - snarf_region => request_region
105 * - aha152x_intr interface change
106 *
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
111 *
112 * Revision 1.6 1994/11/24 20:35:27 root
113 * - problem with odd number of bytes in fifo fixed
114 *
115 * Revision 1.5 1994/10/30 14:39:56 root
116 * - abort code fixed
117 * - debugging improved
118 *
119 * Revision 1.4 1994/09/12 11:33:01 root
120 * - irqaction to request_irq
121 * - abortion updated
122 *
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
127 *
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...)
132 *
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
136 *
137 * Revision 1.0 1994/03/25 12:52:00 root
138 * - Fixed "more data than expected" problem
139 * - added new BIOS signatures
140 *
141 * Revision 0.102 1994/01/31 20:44:12 root
142 * - minor changes in insw/outsw handling
143 *
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)
147 *
148 * Revision 0.100 1993/12/10 16:58:47 root
149 * - fix for unsuccessful selections in case of non-continuous id assignments
150 * on the scsi bus.
151 *
152 * Revision 0.99 1993/10/24 16:19:59 root
153 * - fixed DATA IN (rare read errors gone)
154 *
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
158 *
159 * Revision 0.97 1993/10/09 18:53:53 root
160 * - DATA IN fixed. Rarely left data in the fifo.
161 *
162 * Revision 0.96 1993/10/03 00:53:59 root
163 * - minor changes on DATA IN
164 *
165 * Revision 0.95 1993/09/24 10:36:01 root
166 * - change handling of MSGI after reselection
167 * - fixed sti/cli
168 * - minor changes
169 *
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
174 * - reset corrected
175 * - changed message handling
176 *
177 * Revision 0.93 1993/09/15 20:41:19 root
178 * - fixed bugs with multiple outstanding commands
179 *
180 * Revision 0.92 1993/09/13 02:46:33 root
181 * - multiple outstanding commands work (no problems with IBM drive)
182 *
183 * Revision 0.91 1993/09/12 20:51:46 root
184 * added multiple outstanding commands
185 * (some problem with this $%&? IBM device remain)
186 *
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
191 *
192 * Revision 0.8 1993/09/06 23:09:39 root
193 * - added support for the drive activity light
194 * - minor changes
195 *
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
199 *
200 * Revision 0.6 1993/09/02 11:01:38 root
201 * first public release; added some signatures and biosparam()
202 *
203 * Revision 0.5 1993/08/30 10:23:30 root
204 * fixed timing problems with my IBM drive
205 *
206 * Revision 0.4 1993/08/29 14:06:52 root
207 * fixed some problems with timeouts due incomplete commands
208 *
209 * Revision 0.3 1993/08/28 15:55:03 root
210 * writing data works too. mounted and worked on a dos partition
211 *
212 * Revision 0.2 1993/08/27 22:42:07 root
213 * reading data works. Mounted a msdos partition.
214 *
215 * Revision 0.1 1993/08/25 13:38:30 root
216 * first "damn thing doesn't work" version
217 *
218 * Revision 0.0 1993/08/14 19:54:25 root
219 * empty function bodies; detect() works.
220 *
221 **************************************************************************
222
223 see Documentation/scsi/aha152x.rst for configuration details
224
225 **************************************************************************/
226
227#include <linux/module.h>
228#include <asm/irq.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
247#include <scsi/scsi.h>
248#include <scsi/scsi_cmnd.h>
249#include <scsi/scsi_dbg.h>
250#include <scsi/scsi_device.h>
251#include <scsi/scsi_eh.h>
252#include <scsi/scsi_host.h>
253#include <scsi/scsi_tcq.h>
254#include <scsi/scsi_transport_spi.h>
255#include <scsi/scsicam.h>
256#include "aha152x.h"
257
258static LIST_HEAD(aha152x_host_list);
259
260
261/* DEFINES */
262
263/* For PCMCIA cards, always use AUTOCONF */
264#if defined(AHA152X_PCMCIA) || defined(MODULE)
265#if !defined(AUTOCONF)
266#define AUTOCONF
267#endif
268#endif
269
270#if !defined(AUTOCONF) && !defined(SETUP0)
271#error define AUTOCONF or SETUP0
272#endif
273
274#define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
275#define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
276
277#define LEAD "(scsi%d:%d:%d) "
278#define INFO_LEAD KERN_INFO LEAD
279#define CMDINFO(cmd) \
280 (cmd) ? ((cmd)->device->host->host_no) : -1, \
281 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
282 (cmd) ? ((u8)(cmd)->device->lun & 0x07) : -1
283
284static inline void
285CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
286{
287 scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
288}
289
290#define DELAY_DEFAULT 1000
291
292#if defined(AHA152X_PCMCIA)
293#define IRQ_MIN 0
294#define IRQ_MAX 16
295#else
296#define IRQ_MIN 9
297#if defined(__PPC)
298#define IRQ_MAX (nr_irqs-1)
299#else
300#define IRQ_MAX 12
301#endif
302#endif
303
304enum {
305 not_issued = 0x0001, /* command not yet issued */
306 selecting = 0x0002, /* target is being selected */
307 identified = 0x0004, /* IDENTIFY was sent */
308 disconnected = 0x0008, /* target disconnected */
309 completed = 0x0010, /* target sent COMMAND COMPLETE */
310 aborted = 0x0020, /* ABORT was sent */
311 resetted = 0x0040, /* BUS DEVICE RESET was sent */
312 spiordy = 0x0080, /* waiting for SPIORDY to raise */
313 syncneg = 0x0100, /* synchronous negotiation in progress */
314 aborting = 0x0200, /* ABORT is pending */
315 resetting = 0x0400, /* BUS DEVICE RESET is pending */
316 check_condition = 0x0800, /* requesting sense after CHECK CONDITION */
317};
318
319struct aha152x_cmd_priv {
320 char *ptr;
321 int this_residual;
322 struct scatterlist *buffer;
323 int status;
324 int message;
325 int sent_command;
326 int phase;
327};
328
329static struct aha152x_cmd_priv *aha152x_priv(struct scsi_cmnd *cmd)
330{
331 return scsi_cmd_priv(cmd);
332}
333
334MODULE_AUTHOR("Jürgen Fischer");
335MODULE_DESCRIPTION(AHA152X_REVID);
336MODULE_LICENSE("GPL");
337
338#if !defined(AHA152X_PCMCIA)
339#if defined(MODULE)
340static int io[] = {0, 0};
341module_param_hw_array(io, int, ioport, NULL, 0);
342MODULE_PARM_DESC(io,"base io address of controller");
343
344static int irq[] = {0, 0};
345module_param_hw_array(irq, int, irq, NULL, 0);
346MODULE_PARM_DESC(irq,"interrupt for controller");
347
348static int scsiid[] = {7, 7};
349module_param_array(scsiid, int, NULL, 0);
350MODULE_PARM_DESC(scsiid,"scsi id of controller");
351
352static int reconnect[] = {1, 1};
353module_param_array(reconnect, int, NULL, 0);
354MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
355
356static int parity[] = {1, 1};
357module_param_array(parity, int, NULL, 0);
358MODULE_PARM_DESC(parity,"use scsi parity");
359
360static int sync[] = {1, 1};
361module_param_array(sync, int, NULL, 0);
362MODULE_PARM_DESC(sync,"use synchronous transfers");
363
364static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
365module_param_array(delay, int, NULL, 0);
366MODULE_PARM_DESC(delay,"scsi reset delay");
367
368static int exttrans[] = {0, 0};
369module_param_array(exttrans, int, NULL, 0);
370MODULE_PARM_DESC(exttrans,"use extended translation");
371
372static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
373module_param_array(aha152x, int, NULL, 0);
374MODULE_PARM_DESC(aha152x, "parameters for first controller");
375
376static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
377module_param_array(aha152x1, int, NULL, 0);
378MODULE_PARM_DESC(aha152x1, "parameters for second controller");
379#endif /* MODULE */
380
381#ifdef __ISAPNP__
382static struct isapnp_device_id id_table[] = {
383 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
384 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
385 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
386 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
387 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
388 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
389 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
390 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
391 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
392 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
393 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
394 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
395 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
396 { ISAPNP_DEVICE_SINGLE_END, }
397};
398MODULE_DEVICE_TABLE(isapnp, id_table);
399#endif /* ISAPNP */
400
401#endif /* !AHA152X_PCMCIA */
402
403static const struct scsi_host_template aha152x_driver_template;
404
405/*
406 * internal states of the host
407 *
408 */
409enum aha152x_state {
410 idle=0,
411 unknown,
412 seldo,
413 seldi,
414 selto,
415 busfree,
416 msgo,
417 cmd,
418 msgi,
419 status,
420 datai,
421 datao,
422 parerr,
423 rsti,
424 maxstate
425};
426
427/*
428 * current state information of the host
429 *
430 */
431struct aha152x_hostdata {
432 struct scsi_cmnd *issue_SC;
433 /* pending commands to issue */
434
435 struct scsi_cmnd *current_SC;
436 /* current command on the bus */
437
438 struct scsi_cmnd *disconnected_SC;
439 /* commands that disconnected */
440
441 struct scsi_cmnd *done_SC;
442 /* command that was completed */
443
444 spinlock_t lock;
445 /* host lock */
446
447#if defined(AHA152X_STAT)
448 int total_commands;
449 int disconnections;
450 int busfree_without_any_action;
451 int busfree_without_old_command;
452 int busfree_without_new_command;
453 int busfree_without_done_command;
454 int busfree_with_check_condition;
455 int count[maxstate];
456 int count_trans[maxstate];
457 unsigned long time[maxstate];
458#endif
459
460 int commands; /* current number of commands */
461
462 int reconnect; /* disconnection allowed */
463 int parity; /* parity checking enabled */
464 int synchronous; /* synchronous transferes enabled */
465 int delay; /* reset out delay */
466 int ext_trans; /* extended translation enabled */
467
468 int swint; /* software-interrupt was fired during detect() */
469 int service; /* bh needs to be run */
470 int in_intr; /* bh is running */
471
472 /* current state,
473 previous state,
474 last state different from current state */
475 enum aha152x_state state, prevstate, laststate;
476
477 int target;
478 /* reconnecting target */
479
480 unsigned char syncrate[8];
481 /* current synchronous transfer agreements */
482
483 unsigned char syncneg[8];
484 /* 0: no negotiation;
485 * 1: negotiation in progress;
486 * 2: negotiation completed
487 */
488
489 int cmd_i;
490 /* number of sent bytes of current command */
491
492 int msgi_len;
493 /* number of received message bytes */
494 unsigned char msgi[256];
495 /* received message bytes */
496
497 int msgo_i, msgo_len;
498 /* number of sent bytes and length of current messages */
499 unsigned char msgo[256];
500 /* pending messages */
501
502 int data_len;
503 /* number of sent/received bytes in dataphase */
504
505 unsigned long io_port0;
506 unsigned long io_port1;
507
508#ifdef __ISAPNP__
509 struct pnp_dev *pnpdev;
510#endif
511 struct list_head host_list;
512};
513
514
515/*
516 * host specific command extension
517 *
518 */
519struct aha152x_scdata {
520 struct scsi_cmnd *next; /* next sc in queue */
521 struct completion *done;/* semaphore to block on */
522 struct scsi_eh_save ses;
523};
524
525/* access macros for hostdata */
526
527#define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
528
529#define HOSTNO ((shpnt)->host_no)
530
531#define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
532#define DONE_SC (HOSTDATA(shpnt)->done_SC)
533#define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
534#define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
535#define QLOCK (HOSTDATA(shpnt)->lock)
536#define QLOCKER (HOSTDATA(shpnt)->locker)
537#define QLOCKERL (HOSTDATA(shpnt)->lockerl)
538
539#define STATE (HOSTDATA(shpnt)->state)
540#define PREVSTATE (HOSTDATA(shpnt)->prevstate)
541#define LASTSTATE (HOSTDATA(shpnt)->laststate)
542
543#define RECONN_TARGET (HOSTDATA(shpnt)->target)
544
545#define CMD_I (HOSTDATA(shpnt)->cmd_i)
546
547#define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
548#define MSGO_I (HOSTDATA(shpnt)->msgo_i)
549#define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
550#define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
551
552#define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
553#define MSGILEN (HOSTDATA(shpnt)->msgi_len)
554#define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
555
556#define DATA_LEN (HOSTDATA(shpnt)->data_len)
557
558#define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
559#define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
560
561#define DELAY (HOSTDATA(shpnt)->delay)
562#define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
563#define TC1550 (HOSTDATA(shpnt)->tc1550)
564#define RECONNECT (HOSTDATA(shpnt)->reconnect)
565#define PARITY (HOSTDATA(shpnt)->parity)
566#define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
567
568#define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
569#define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
570
571#define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
572#define SCNEXT(SCpnt) SCDATA(SCpnt)->next
573#define SCSEM(SCpnt) SCDATA(SCpnt)->done
574
575#define SG_ADDRESS(buffer) ((char *) sg_virt((buffer)))
576
577/* state handling */
578static void seldi_run(struct Scsi_Host *shpnt);
579static void seldo_run(struct Scsi_Host *shpnt);
580static void selto_run(struct Scsi_Host *shpnt);
581static void busfree_run(struct Scsi_Host *shpnt);
582
583static void msgo_init(struct Scsi_Host *shpnt);
584static void msgo_run(struct Scsi_Host *shpnt);
585static void msgo_end(struct Scsi_Host *shpnt);
586
587static void cmd_init(struct Scsi_Host *shpnt);
588static void cmd_run(struct Scsi_Host *shpnt);
589static void cmd_end(struct Scsi_Host *shpnt);
590
591static void datai_init(struct Scsi_Host *shpnt);
592static void datai_run(struct Scsi_Host *shpnt);
593static void datai_end(struct Scsi_Host *shpnt);
594
595static void datao_init(struct Scsi_Host *shpnt);
596static void datao_run(struct Scsi_Host *shpnt);
597static void datao_end(struct Scsi_Host *shpnt);
598
599static void status_run(struct Scsi_Host *shpnt);
600
601static void msgi_run(struct Scsi_Host *shpnt);
602static void msgi_end(struct Scsi_Host *shpnt);
603
604static void parerr_run(struct Scsi_Host *shpnt);
605static void rsti_run(struct Scsi_Host *shpnt);
606
607static void is_complete(struct Scsi_Host *shpnt);
608
609/*
610 * driver states
611 *
612 */
613static struct {
614 char *name;
615 void (*init)(struct Scsi_Host *);
616 void (*run)(struct Scsi_Host *);
617 void (*end)(struct Scsi_Host *);
618 int spio;
619} states[] = {
620 { "idle", NULL, NULL, NULL, 0},
621 { "unknown", NULL, NULL, NULL, 0},
622 { "seldo", NULL, seldo_run, NULL, 0},
623 { "seldi", NULL, seldi_run, NULL, 0},
624 { "selto", NULL, selto_run, NULL, 0},
625 { "busfree", NULL, busfree_run, NULL, 0},
626 { "msgo", msgo_init, msgo_run, msgo_end, 1},
627 { "cmd", cmd_init, cmd_run, cmd_end, 1},
628 { "msgi", NULL, msgi_run, msgi_end, 1},
629 { "status", NULL, status_run, NULL, 1},
630 { "datai", datai_init, datai_run, datai_end, 0},
631 { "datao", datao_init, datao_run, datao_end, 0},
632 { "parerr", NULL, parerr_run, NULL, 0},
633 { "rsti", NULL, rsti_run, NULL, 0},
634};
635
636/* setup & interrupt */
637static irqreturn_t intr(int irq, void *dev_id);
638static void reset_ports(struct Scsi_Host *shpnt);
639static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
640static void done(struct Scsi_Host *shpnt, unsigned char status_byte,
641 unsigned char host_byte);
642
643/* diagnostics */
644static void show_command(struct scsi_cmnd * ptr);
645static void show_queues(struct Scsi_Host *shpnt);
646static void disp_enintr(struct Scsi_Host *shpnt);
647
648
649/*
650 * queue services:
651 *
652 */
653static inline void append_SC(struct scsi_cmnd **SC, struct scsi_cmnd *new_SC)
654{
655 struct scsi_cmnd *end;
656
657 SCNEXT(new_SC) = NULL;
658 if (!*SC)
659 *SC = new_SC;
660 else {
661 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
662 ;
663 SCNEXT(end) = new_SC;
664 }
665}
666
667static inline struct scsi_cmnd *remove_first_SC(struct scsi_cmnd ** SC)
668{
669 struct scsi_cmnd *ptr;
670
671 ptr = *SC;
672 if (ptr) {
673 *SC = SCNEXT(*SC);
674 SCNEXT(ptr)=NULL;
675 }
676 return ptr;
677}
678
679static inline struct scsi_cmnd *remove_lun_SC(struct scsi_cmnd ** SC,
680 int target, int lun)
681{
682 struct scsi_cmnd *ptr, *prev;
683
684 for (ptr = *SC, prev = NULL;
685 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
686 prev = ptr, ptr = SCNEXT(ptr))
687 ;
688
689 if (ptr) {
690 if (prev)
691 SCNEXT(prev) = SCNEXT(ptr);
692 else
693 *SC = SCNEXT(ptr);
694
695 SCNEXT(ptr)=NULL;
696 }
697
698 return ptr;
699}
700
701static inline struct scsi_cmnd *remove_SC(struct scsi_cmnd **SC,
702 struct scsi_cmnd *SCp)
703{
704 struct scsi_cmnd *ptr, *prev;
705
706 for (ptr = *SC, prev = NULL;
707 ptr && SCp!=ptr;
708 prev = ptr, ptr = SCNEXT(ptr))
709 ;
710
711 if (ptr) {
712 if (prev)
713 SCNEXT(prev) = SCNEXT(ptr);
714 else
715 *SC = SCNEXT(ptr);
716
717 SCNEXT(ptr)=NULL;
718 }
719
720 return ptr;
721}
722
723static irqreturn_t swintr(int irqno, void *dev_id)
724{
725 struct Scsi_Host *shpnt = dev_id;
726
727 HOSTDATA(shpnt)->swint++;
728
729 SETPORT(DMACNTRL0, INTEN);
730 return IRQ_HANDLED;
731}
732
733struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
734{
735 struct Scsi_Host *shpnt;
736
737 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
738 if (!shpnt) {
739 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
740 return NULL;
741 }
742
743 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
744 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
745
746 /* need to have host registered before triggering any interrupt */
747 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
748
749 shpnt->io_port = setup->io_port;
750 shpnt->n_io_port = IO_RANGE;
751 shpnt->irq = setup->irq;
752
753 if (!setup->tc1550) {
754 HOSTIOPORT0 = setup->io_port;
755 HOSTIOPORT1 = setup->io_port;
756 } else {
757 HOSTIOPORT0 = setup->io_port+0x10;
758 HOSTIOPORT1 = setup->io_port-0x10;
759 }
760
761 spin_lock_init(&QLOCK);
762 RECONNECT = setup->reconnect;
763 SYNCHRONOUS = setup->synchronous;
764 PARITY = setup->parity;
765 DELAY = setup->delay;
766 EXT_TRANS = setup->ext_trans;
767
768 SETPORT(SCSIID, setup->scsiid << 4);
769 shpnt->this_id = setup->scsiid;
770
771 if (setup->reconnect)
772 shpnt->can_queue = AHA152X_MAXQUEUE;
773
774 /* RESET OUT */
775 printk("aha152x: resetting bus...\n");
776 SETPORT(SCSISEQ, SCSIRSTO);
777 mdelay(256);
778 SETPORT(SCSISEQ, 0);
779 mdelay(DELAY);
780
781 reset_ports(shpnt);
782
783 printk(KERN_INFO
784 "aha152x%d%s: "
785 "vital data: rev=%x, "
786 "io=0x%03lx (0x%03lx/0x%03lx), "
787 "irq=%d, "
788 "scsiid=%d, "
789 "reconnect=%s, "
790 "parity=%s, "
791 "synchronous=%s, "
792 "delay=%d, "
793 "extended translation=%s\n",
794 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
795 GETPORT(REV) & 0x7,
796 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
797 shpnt->irq,
798 shpnt->this_id,
799 RECONNECT ? "enabled" : "disabled",
800 PARITY ? "enabled" : "disabled",
801 SYNCHRONOUS ? "enabled" : "disabled",
802 DELAY,
803 EXT_TRANS ? "enabled" : "disabled");
804
805 /* not expecting any interrupts */
806 SETPORT(SIMODE0, 0);
807 SETPORT(SIMODE1, 0);
808
809 if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) {
810 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
811 goto out_host_put;
812 }
813
814 HOSTDATA(shpnt)->swint = 0;
815
816 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
817
818 mb();
819 SETPORT(DMACNTRL0, SWINT|INTEN);
820 mdelay(1000);
821 free_irq(shpnt->irq, shpnt);
822
823 if (!HOSTDATA(shpnt)->swint) {
824 if (TESTHI(DMASTAT, INTSTAT)) {
825 printk("lost.\n");
826 } else {
827 printk("failed.\n");
828 }
829
830 SETPORT(DMACNTRL0, INTEN);
831
832 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
833 "Please verify.\n", shpnt->host_no, shpnt->irq);
834 goto out_host_put;
835 }
836 printk("ok.\n");
837
838
839 /* clear interrupts */
840 SETPORT(SSTAT0, 0x7f);
841 SETPORT(SSTAT1, 0xef);
842
843 if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) {
844 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
845 goto out_host_put;
846 }
847
848 if( scsi_add_host(shpnt, NULL) ) {
849 free_irq(shpnt->irq, shpnt);
850 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
851 goto out_host_put;
852 }
853
854 scsi_scan_host(shpnt);
855
856 return shpnt;
857
858out_host_put:
859 list_del(&HOSTDATA(shpnt)->host_list);
860 scsi_host_put(shpnt);
861
862 return NULL;
863}
864
865void aha152x_release(struct Scsi_Host *shpnt)
866{
867 if (!shpnt)
868 return;
869
870 scsi_remove_host(shpnt);
871 if (shpnt->irq)
872 free_irq(shpnt->irq, shpnt);
873
874#if !defined(AHA152X_PCMCIA)
875 if (shpnt->io_port)
876 release_region(shpnt->io_port, IO_RANGE);
877#endif
878
879#ifdef __ISAPNP__
880 if (HOSTDATA(shpnt)->pnpdev)
881 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
882#endif
883
884 list_del(&HOSTDATA(shpnt)->host_list);
885 scsi_host_put(shpnt);
886}
887
888
889/*
890 * setup controller to generate interrupts depending
891 * on current state (lock has to be acquired)
892 *
893 */
894static int setup_expected_interrupts(struct Scsi_Host *shpnt)
895{
896 if(CURRENT_SC) {
897 struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
898
899 acp->phase |= 1 << 16;
900
901 if (acp->phase & selecting) {
902 SETPORT(SSTAT1, SELTO);
903 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
904 SETPORT(SIMODE1, ENSELTIMO);
905 } else {
906 SETPORT(SIMODE0, (acp->phase & spiordy) ? ENSPIORDY : 0);
907 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
908 }
909 } else if(STATE==seldi) {
910 SETPORT(SIMODE0, 0);
911 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
912 } else {
913 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
914 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
915 }
916
917 if(!HOSTDATA(shpnt)->in_intr)
918 SETBITS(DMACNTRL0, INTEN);
919
920 return TESTHI(DMASTAT, INTSTAT);
921}
922
923
924/*
925 * Queue a command and setup interrupts for a free bus.
926 */
927static int aha152x_internal_queue(struct scsi_cmnd *SCpnt,
928 struct completion *complete, int phase)
929{
930 struct aha152x_cmd_priv *acp = aha152x_priv(SCpnt);
931 struct Scsi_Host *shpnt = SCpnt->device->host;
932 unsigned long flags;
933
934 acp->phase = not_issued | phase;
935 acp->status = 0x1; /* Illegal status by SCSI standard */
936 acp->message = 0;
937 acp->sent_command = 0;
938
939 if (acp->phase & (resetting | check_condition)) {
940 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
941 scmd_printk(KERN_ERR, SCpnt, "cannot reuse command\n");
942 return FAILED;
943 }
944 } else {
945 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
946 if(!SCpnt->host_scribble) {
947 scmd_printk(KERN_ERR, SCpnt, "allocation failed\n");
948 return FAILED;
949 }
950 }
951
952 SCNEXT(SCpnt) = NULL;
953 SCSEM(SCpnt) = complete;
954
955 /* setup scratch area
956 SCp.ptr : buffer pointer
957 SCp.this_residual : buffer length
958 SCp.buffer : next buffer
959 SCp.phase : current state of the command */
960
961 if ((phase & resetting) || !scsi_sglist(SCpnt)) {
962 acp->ptr = NULL;
963 acp->this_residual = 0;
964 scsi_set_resid(SCpnt, 0);
965 acp->buffer = NULL;
966 } else {
967 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
968 acp->buffer = scsi_sglist(SCpnt);
969 acp->ptr = SG_ADDRESS(acp->buffer);
970 acp->this_residual = acp->buffer->length;
971 }
972
973 DO_LOCK(flags);
974
975#if defined(AHA152X_STAT)
976 HOSTDATA(shpnt)->total_commands++;
977#endif
978
979 /* Turn led on, when this is the first command. */
980 HOSTDATA(shpnt)->commands++;
981 if (HOSTDATA(shpnt)->commands==1)
982 SETPORT(PORTA, 1);
983
984 append_SC(&ISSUE_SC, SCpnt);
985
986 if(!HOSTDATA(shpnt)->in_intr)
987 setup_expected_interrupts(shpnt);
988
989 DO_UNLOCK(flags);
990
991 return 0;
992}
993
994/*
995 * queue a command
996 *
997 */
998static int aha152x_queue_lck(struct scsi_cmnd *SCpnt)
999{
1000 return aha152x_internal_queue(SCpnt, NULL, 0);
1001}
1002
1003static DEF_SCSI_QCMD(aha152x_queue)
1004
1005
1006/*
1007 *
1008 */
1009static void reset_done(struct scsi_cmnd *SCpnt)
1010{
1011 if(SCSEM(SCpnt)) {
1012 complete(SCSEM(SCpnt));
1013 } else {
1014 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1015 }
1016}
1017
1018static void aha152x_scsi_done(struct scsi_cmnd *SCpnt)
1019{
1020 if (aha152x_priv(SCpnt)->phase & resetting)
1021 reset_done(SCpnt);
1022 else
1023 scsi_done(SCpnt);
1024}
1025
1026/*
1027 * Abort a command
1028 *
1029 */
1030static int aha152x_abort(struct scsi_cmnd *SCpnt)
1031{
1032 struct Scsi_Host *shpnt = SCpnt->device->host;
1033 struct scsi_cmnd *ptr;
1034 unsigned long flags;
1035
1036 DO_LOCK(flags);
1037
1038 ptr=remove_SC(&ISSUE_SC, SCpnt);
1039
1040 if(ptr) {
1041 HOSTDATA(shpnt)->commands--;
1042 if (!HOSTDATA(shpnt)->commands)
1043 SETPORT(PORTA, 0);
1044 DO_UNLOCK(flags);
1045
1046 kfree(SCpnt->host_scribble);
1047 SCpnt->host_scribble=NULL;
1048
1049 return SUCCESS;
1050 }
1051
1052 DO_UNLOCK(flags);
1053
1054 /*
1055 * FIXME:
1056 * for current command: queue ABORT for message out and raise ATN
1057 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1058 *
1059 */
1060
1061 scmd_printk(KERN_ERR, SCpnt,
1062 "cannot abort running or disconnected command\n");
1063
1064 return FAILED;
1065}
1066
1067/*
1068 * Reset a device
1069 *
1070 */
1071static int aha152x_device_reset(struct scsi_cmnd * SCpnt)
1072{
1073 struct Scsi_Host *shpnt = SCpnt->device->host;
1074 DECLARE_COMPLETION(done);
1075 int ret, issued, disconnected;
1076 unsigned char old_cmd_len = SCpnt->cmd_len;
1077 unsigned long flags;
1078 unsigned long timeleft;
1079
1080 if(CURRENT_SC==SCpnt) {
1081 scmd_printk(KERN_ERR, SCpnt, "cannot reset current device\n");
1082 return FAILED;
1083 }
1084
1085 DO_LOCK(flags);
1086 issued = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1087 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1088 DO_UNLOCK(flags);
1089
1090 SCpnt->cmd_len = 0;
1091
1092 aha152x_internal_queue(SCpnt, &done, resetting);
1093
1094 timeleft = wait_for_completion_timeout(&done, 100*HZ);
1095 if (!timeleft) {
1096 /* remove command from issue queue */
1097 DO_LOCK(flags);
1098 remove_SC(&ISSUE_SC, SCpnt);
1099 DO_UNLOCK(flags);
1100 }
1101
1102 SCpnt->cmd_len = old_cmd_len;
1103
1104 DO_LOCK(flags);
1105
1106 if (aha152x_priv(SCpnt)->phase & resetted) {
1107 HOSTDATA(shpnt)->commands--;
1108 if (!HOSTDATA(shpnt)->commands)
1109 SETPORT(PORTA, 0);
1110 kfree(SCpnt->host_scribble);
1111 SCpnt->host_scribble=NULL;
1112
1113 ret = SUCCESS;
1114 } else {
1115 /* requeue */
1116 if(!issued) {
1117 append_SC(&ISSUE_SC, SCpnt);
1118 } else if(disconnected) {
1119 append_SC(&DISCONNECTED_SC, SCpnt);
1120 }
1121
1122 ret = FAILED;
1123 }
1124
1125 DO_UNLOCK(flags);
1126 return ret;
1127}
1128
1129static void free_hard_reset_SCs(struct Scsi_Host *shpnt,
1130 struct scsi_cmnd **SCs)
1131{
1132 struct scsi_cmnd *ptr;
1133
1134 ptr=*SCs;
1135 while(ptr) {
1136 struct scsi_cmnd *next;
1137
1138 if(SCDATA(ptr)) {
1139 next = SCNEXT(ptr);
1140 } else {
1141 scmd_printk(KERN_DEBUG, ptr,
1142 "queue corrupted at %p\n", ptr);
1143 next = NULL;
1144 }
1145
1146 if (!ptr->device->soft_reset) {
1147 remove_SC(SCs, ptr);
1148 HOSTDATA(shpnt)->commands--;
1149 kfree(ptr->host_scribble);
1150 ptr->host_scribble=NULL;
1151 }
1152
1153 ptr = next;
1154 }
1155}
1156
1157/*
1158 * Reset the bus
1159 *
1160 * AIC-6260 has a hard reset (MRST signal), but apparently
1161 * one cannot trigger it via software. So live with
1162 * a soft reset; no-one seemed to have cared.
1163 */
1164static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1165{
1166 unsigned long flags;
1167
1168 DO_LOCK(flags);
1169
1170 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1171 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1172
1173 SETPORT(SCSISEQ, SCSIRSTO);
1174 mdelay(256);
1175 SETPORT(SCSISEQ, 0);
1176 mdelay(DELAY);
1177
1178 setup_expected_interrupts(shpnt);
1179 if(HOSTDATA(shpnt)->commands==0)
1180 SETPORT(PORTA, 0);
1181
1182 DO_UNLOCK(flags);
1183
1184 return SUCCESS;
1185}
1186
1187/*
1188 * Reset the bus
1189 *
1190 */
1191static int aha152x_bus_reset(struct scsi_cmnd *SCpnt)
1192{
1193 return aha152x_bus_reset_host(SCpnt->device->host);
1194}
1195
1196/*
1197 * Restore default values to the AIC-6260 registers and reset the fifos
1198 *
1199 */
1200static void reset_ports(struct Scsi_Host *shpnt)
1201{
1202 unsigned long flags;
1203
1204 /* disable interrupts */
1205 SETPORT(DMACNTRL0, RSTFIFO);
1206
1207 SETPORT(SCSISEQ, 0);
1208
1209 SETPORT(SXFRCTL1, 0);
1210 SETPORT(SCSISIG, 0);
1211 SETRATE(0);
1212
1213 /* clear all interrupt conditions */
1214 SETPORT(SSTAT0, 0x7f);
1215 SETPORT(SSTAT1, 0xef);
1216
1217 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1218
1219 SETPORT(DMACNTRL0, 0);
1220 SETPORT(DMACNTRL1, 0);
1221
1222 SETPORT(BRSTCNTRL, 0xf1);
1223
1224 /* clear SCSI fifos and transfer count */
1225 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1226 SETPORT(SXFRCTL0, CH1);
1227
1228 DO_LOCK(flags);
1229 setup_expected_interrupts(shpnt);
1230 DO_UNLOCK(flags);
1231}
1232
1233/*
1234 * Reset the host (bus and controller)
1235 *
1236 */
1237int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1238{
1239 aha152x_bus_reset_host(shpnt);
1240 reset_ports(shpnt);
1241
1242 return SUCCESS;
1243}
1244
1245/*
1246 * Return the "logical geometry"
1247 *
1248 */
1249static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1250 sector_t capacity, int *info_array)
1251{
1252 struct Scsi_Host *shpnt = sdev->host;
1253
1254 /* try default translation */
1255 info_array[0] = 64;
1256 info_array[1] = 32;
1257 info_array[2] = (unsigned long)capacity / (64 * 32);
1258
1259 /* for disks >1GB do some guessing */
1260 if (info_array[2] >= 1024) {
1261 int info[3];
1262
1263 /* try to figure out the geometry from the partition table */
1264 if (scsicam_bios_param(bdev, capacity, info) < 0 ||
1265 !((info[0] == 64 && info[1] == 32) || (info[0] == 255 && info[1] == 63))) {
1266 if (EXT_TRANS) {
1267 printk(KERN_NOTICE
1268 "aha152x: unable to verify geometry for disk with >1GB.\n"
1269 " using extended translation.\n");
1270 info_array[0] = 255;
1271 info_array[1] = 63;
1272 info_array[2] = (unsigned long)capacity / (255 * 63);
1273 } else {
1274 printk(KERN_NOTICE
1275 "aha152x: unable to verify geometry for disk with >1GB.\n"
1276 " Using default translation. Please verify yourself.\n"
1277 " Perhaps you need to enable extended translation in the driver.\n"
1278 " See Documentation/scsi/aha152x.rst for details.\n");
1279 }
1280 } else {
1281 info_array[0] = info[0];
1282 info_array[1] = info[1];
1283 info_array[2] = info[2];
1284
1285 if (info[0] == 255 && !EXT_TRANS) {
1286 printk(KERN_NOTICE
1287 "aha152x: current partition table is using extended translation.\n"
1288 " using it also, although it's not explicitly enabled.\n");
1289 }
1290 }
1291 }
1292
1293 return 0;
1294}
1295
1296/*
1297 * Internal done function
1298 *
1299 */
1300static void done(struct Scsi_Host *shpnt, unsigned char status_byte,
1301 unsigned char host_byte)
1302{
1303 if (CURRENT_SC) {
1304 if(DONE_SC)
1305 scmd_printk(KERN_ERR, CURRENT_SC,
1306 "there's already a completed command %p "
1307 "- will cause abort\n", DONE_SC);
1308
1309 DONE_SC = CURRENT_SC;
1310 CURRENT_SC = NULL;
1311 set_status_byte(DONE_SC, status_byte);
1312 set_host_byte(DONE_SC, host_byte);
1313 } else
1314 printk(KERN_ERR "aha152x: done() called outside of command\n");
1315}
1316
1317static struct work_struct aha152x_tq;
1318
1319/*
1320 * Run service completions on the card with interrupts enabled.
1321 *
1322 */
1323static void run(struct work_struct *work)
1324{
1325 struct aha152x_hostdata *hd;
1326
1327 list_for_each_entry(hd, &aha152x_host_list, host_list) {
1328 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1329
1330 is_complete(shost);
1331 }
1332}
1333
1334/*
1335 * Interrupt handler
1336 *
1337 */
1338static irqreturn_t intr(int irqno, void *dev_id)
1339{
1340 struct Scsi_Host *shpnt = dev_id;
1341 unsigned long flags;
1342 unsigned char rev, dmacntrl0;
1343
1344 /*
1345 * Read a couple of registers that are known to not be all 1's. If
1346 * we read all 1's (-1), that means that either:
1347 *
1348 * a. The host adapter chip has gone bad, and we cannot control it,
1349 * OR
1350 * b. The host adapter is a PCMCIA card that has been ejected
1351 *
1352 * In either case, we cannot do anything with the host adapter at
1353 * this point in time. So just ignore the interrupt and return.
1354 * In the latter case, the interrupt might actually be meant for
1355 * someone else sharing this IRQ, and that driver will handle it.
1356 */
1357 rev = GETPORT(REV);
1358 dmacntrl0 = GETPORT(DMACNTRL0);
1359 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1360 return IRQ_NONE;
1361
1362 if( TESTLO(DMASTAT, INTSTAT) )
1363 return IRQ_NONE;
1364
1365 /* no more interrupts from the controller, while we're busy.
1366 INTEN is restored by the BH handler */
1367 CLRBITS(DMACNTRL0, INTEN);
1368
1369 DO_LOCK(flags);
1370 if( HOSTDATA(shpnt)->service==0 ) {
1371 HOSTDATA(shpnt)->service=1;
1372
1373 /* Poke the BH handler */
1374 INIT_WORK(&aha152x_tq, run);
1375 schedule_work(&aha152x_tq);
1376 }
1377 DO_UNLOCK(flags);
1378
1379 return IRQ_HANDLED;
1380}
1381
1382/*
1383 * busfree phase
1384 * - handle completition/disconnection/error of current command
1385 * - start selection for next command (if any)
1386 */
1387static void busfree_run(struct Scsi_Host *shpnt)
1388{
1389 unsigned long flags;
1390#if defined(AHA152X_STAT)
1391 int action=0;
1392#endif
1393
1394 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1395 SETPORT(SXFRCTL0, CH1);
1396
1397 SETPORT(SSTAT1, CLRBUSFREE);
1398
1399 if(CURRENT_SC) {
1400 struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1401
1402#if defined(AHA152X_STAT)
1403 action++;
1404#endif
1405 acp->phase &= ~syncneg;
1406
1407 if (acp->phase & completed) {
1408 /* target sent COMMAND COMPLETE */
1409 done(shpnt, acp->status, DID_OK);
1410
1411 } else if (acp->phase & aborted) {
1412 done(shpnt, acp->status, DID_ABORT);
1413
1414 } else if (acp->phase & resetted) {
1415 done(shpnt, acp->status, DID_RESET);
1416
1417 } else if (acp->phase & disconnected) {
1418 /* target sent DISCONNECT */
1419#if defined(AHA152X_STAT)
1420 HOSTDATA(shpnt)->disconnections++;
1421#endif
1422 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1423 acp->phase |= 1 << 16;
1424 CURRENT_SC = NULL;
1425
1426 } else {
1427 done(shpnt, SAM_STAT_GOOD, DID_ERROR);
1428 }
1429#if defined(AHA152X_STAT)
1430 } else {
1431 HOSTDATA(shpnt)->busfree_without_old_command++;
1432#endif
1433 }
1434
1435 DO_LOCK(flags);
1436
1437 if(DONE_SC) {
1438#if defined(AHA152X_STAT)
1439 action++;
1440#endif
1441
1442 if (aha152x_priv(DONE_SC)->phase & check_condition) {
1443 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1444 struct aha152x_scdata *sc = SCDATA(cmd);
1445
1446 scsi_eh_restore_cmnd(cmd, &sc->ses);
1447
1448 aha152x_priv(cmd)->status = SAM_STAT_CHECK_CONDITION;
1449
1450 HOSTDATA(shpnt)->commands--;
1451 if (!HOSTDATA(shpnt)->commands)
1452 SETPORT(PORTA, 0); /* turn led off */
1453 } else if (aha152x_priv(DONE_SC)->status == SAM_STAT_CHECK_CONDITION) {
1454#if defined(AHA152X_STAT)
1455 HOSTDATA(shpnt)->busfree_with_check_condition++;
1456#endif
1457
1458 if (!(aha152x_priv(DONE_SC)->phase & not_issued)) {
1459 struct aha152x_scdata *sc;
1460 struct scsi_cmnd *ptr = DONE_SC;
1461 DONE_SC=NULL;
1462
1463 sc = SCDATA(ptr);
1464 /* It was allocated in aha152x_internal_queue? */
1465 BUG_ON(!sc);
1466 scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1467
1468 DO_UNLOCK(flags);
1469 aha152x_internal_queue(ptr, NULL, check_condition);
1470 DO_LOCK(flags);
1471 }
1472 }
1473
1474 if (DONE_SC) {
1475 struct scsi_cmnd *ptr = DONE_SC;
1476 DONE_SC=NULL;
1477
1478 /* turn led off, when no commands are in the driver */
1479 HOSTDATA(shpnt)->commands--;
1480 if (!HOSTDATA(shpnt)->commands)
1481 SETPORT(PORTA, 0); /* turn led off */
1482
1483 if (!(aha152x_priv(ptr)->phase & resetting)) {
1484 kfree(ptr->host_scribble);
1485 ptr->host_scribble=NULL;
1486 }
1487
1488 DO_UNLOCK(flags);
1489 aha152x_scsi_done(ptr);
1490 DO_LOCK(flags);
1491 }
1492
1493 DONE_SC=NULL;
1494#if defined(AHA152X_STAT)
1495 } else {
1496 HOSTDATA(shpnt)->busfree_without_done_command++;
1497#endif
1498 }
1499
1500 if(ISSUE_SC)
1501 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1502
1503 DO_UNLOCK(flags);
1504
1505 if(CURRENT_SC) {
1506 struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1507
1508#if defined(AHA152X_STAT)
1509 action++;
1510#endif
1511 acp->phase |= selecting;
1512
1513 /* clear selection timeout */
1514 SETPORT(SSTAT1, SELTO);
1515
1516 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1517 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1518 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1519 } else {
1520#if defined(AHA152X_STAT)
1521 HOSTDATA(shpnt)->busfree_without_new_command++;
1522#endif
1523 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1524 }
1525
1526#if defined(AHA152X_STAT)
1527 if(!action)
1528 HOSTDATA(shpnt)->busfree_without_any_action++;
1529#endif
1530}
1531
1532/*
1533 * Selection done (OUT)
1534 * - queue IDENTIFY message and SDTR to selected target for message out
1535 * (ATN asserted automagically via ENAUTOATNO in busfree())
1536 */
1537static void seldo_run(struct Scsi_Host *shpnt)
1538{
1539 struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1540
1541 SETPORT(SCSISIG, 0);
1542 SETPORT(SSTAT1, CLRBUSFREE);
1543 SETPORT(SSTAT1, CLRPHASECHG);
1544
1545 acp->phase &= ~(selecting | not_issued);
1546
1547 SETPORT(SCSISEQ, 0);
1548
1549 if (TESTLO(SSTAT0, SELDO)) {
1550 scmd_printk(KERN_ERR, CURRENT_SC,
1551 "aha152x: passing bus free condition\n");
1552 done(shpnt, SAM_STAT_GOOD, DID_NO_CONNECT);
1553 return;
1554 }
1555
1556 SETPORT(SSTAT0, CLRSELDO);
1557
1558 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1559
1560 if (acp->phase & aborting) {
1561 ADDMSGO(ABORT);
1562 } else if (acp->phase & resetting) {
1563 ADDMSGO(BUS_DEVICE_RESET);
1564 } else if (SYNCNEG==0 && SYNCHRONOUS) {
1565 acp->phase |= syncneg;
1566 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1567 SYNCNEG=1; /* negotiation in progress */
1568 }
1569
1570 SETRATE(SYNCRATE);
1571}
1572
1573/*
1574 * Selection timeout
1575 * - return command to mid-level with failure cause
1576 *
1577 */
1578static void selto_run(struct Scsi_Host *shpnt)
1579{
1580 struct aha152x_cmd_priv *acp;
1581
1582 SETPORT(SCSISEQ, 0);
1583 SETPORT(SSTAT1, CLRSELTIMO);
1584
1585 if (!CURRENT_SC)
1586 return;
1587
1588 acp = aha152x_priv(CURRENT_SC);
1589 acp->phase &= ~selecting;
1590
1591 if (acp->phase & aborted)
1592 done(shpnt, SAM_STAT_GOOD, DID_ABORT);
1593 else if (TESTLO(SSTAT0, SELINGO))
1594 done(shpnt, SAM_STAT_GOOD, DID_BUS_BUSY);
1595 else
1596 /* ARBITRATION won, but SELECTION failed */
1597 done(shpnt, SAM_STAT_GOOD, DID_NO_CONNECT);
1598}
1599
1600/*
1601 * Selection in done
1602 * - put current command back to issue queue
1603 * (reconnection of a disconnected nexus instead
1604 * of successful selection out)
1605 *
1606 */
1607static void seldi_run(struct Scsi_Host *shpnt)
1608{
1609 int selid;
1610 int target;
1611 unsigned long flags;
1612
1613 SETPORT(SCSISIG, 0);
1614 SETPORT(SSTAT0, CLRSELDI);
1615 SETPORT(SSTAT1, CLRBUSFREE);
1616 SETPORT(SSTAT1, CLRPHASECHG);
1617
1618 if(CURRENT_SC) {
1619 struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1620
1621 if (!(acp->phase & not_issued))
1622 scmd_printk(KERN_ERR, CURRENT_SC,
1623 "command should not have been issued yet\n");
1624
1625 DO_LOCK(flags);
1626 append_SC(&ISSUE_SC, CURRENT_SC);
1627 DO_UNLOCK(flags);
1628
1629 CURRENT_SC = NULL;
1630 }
1631
1632 if (!DISCONNECTED_SC)
1633 return;
1634
1635 RECONN_TARGET=-1;
1636
1637 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1638
1639 if (selid==0) {
1640 shost_printk(KERN_INFO, shpnt,
1641 "target id unknown (%02x)\n", selid);
1642 return;
1643 }
1644
1645 for(target=7; !(selid & (1 << target)); target--)
1646 ;
1647
1648 if(selid & ~(1 << target)) {
1649 shost_printk(KERN_INFO, shpnt,
1650 "multiple targets reconnected (%02x)\n", selid);
1651 }
1652
1653
1654 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1655 SETPORT(SCSISEQ, 0);
1656
1657 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1658
1659 RECONN_TARGET=target;
1660}
1661
1662/*
1663 * message in phase
1664 * - handle initial message after reconnection to identify
1665 * reconnecting nexus
1666 * - queue command on DISCONNECTED_SC on DISCONNECT message
1667 * - set completed flag on COMMAND COMPLETE
1668 * (other completition code moved to busfree_run)
1669 * - handle response to SDTR
1670 * - clear synchronous transfer agreements on BUS RESET
1671 *
1672 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1673 *
1674 */
1675static void msgi_run(struct Scsi_Host *shpnt)
1676{
1677 for(;;) {
1678 struct aha152x_cmd_priv *acp;
1679 int sstat1 = GETPORT(SSTAT1);
1680
1681 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1682 return;
1683
1684 if (TESTLO(SSTAT0, SPIORDY))
1685 return;
1686
1687 ADDMSGI(GETPORT(SCSIDAT));
1688
1689 if(!CURRENT_SC) {
1690 if(LASTSTATE!=seldi) {
1691 shost_printk(KERN_ERR, shpnt,
1692 "message in w/o current command"
1693 " not after reselection\n");
1694 }
1695
1696 /*
1697 * Handle reselection
1698 */
1699 if(!(MSGI(0) & IDENTIFY_BASE)) {
1700 shost_printk(KERN_ERR, shpnt,
1701 "target didn't identify after reselection\n");
1702 continue;
1703 }
1704
1705 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1706
1707 if (!CURRENT_SC) {
1708 show_queues(shpnt);
1709 shost_printk(KERN_ERR, shpnt,
1710 "no disconnected command"
1711 " for target %d/%d\n",
1712 RECONN_TARGET, MSGI(0) & 0x3f);
1713 continue;
1714 }
1715
1716 acp = aha152x_priv(CURRENT_SC);
1717 acp->message = MSGI(0);
1718 acp->phase &= ~disconnected;
1719
1720 MSGILEN=0;
1721
1722 /* next message if any */
1723 continue;
1724 }
1725
1726 acp = aha152x_priv(CURRENT_SC);
1727 acp->message = MSGI(0);
1728
1729 switch (MSGI(0)) {
1730 case DISCONNECT:
1731 if (!RECONNECT)
1732 scmd_printk(KERN_WARNING, CURRENT_SC,
1733 "target was not allowed to disconnect\n");
1734
1735 acp->phase |= disconnected;
1736 break;
1737
1738 case COMMAND_COMPLETE:
1739 acp->phase |= completed;
1740 break;
1741
1742 case MESSAGE_REJECT:
1743 if (SYNCNEG==1) {
1744 scmd_printk(KERN_INFO, CURRENT_SC,
1745 "Synchronous Data Transfer Request"
1746 " was rejected\n");
1747 SYNCNEG=2; /* negotiation completed */
1748 } else
1749 scmd_printk(KERN_INFO, CURRENT_SC,
1750 "inbound message (MESSAGE REJECT)\n");
1751 break;
1752
1753 case SAVE_POINTERS:
1754 break;
1755
1756 case RESTORE_POINTERS:
1757 break;
1758
1759 case EXTENDED_MESSAGE:
1760 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1761 /* not yet completed */
1762 continue;
1763 }
1764
1765 switch (MSGI(2)) {
1766 case EXTENDED_SDTR:
1767 {
1768 long ticks;
1769
1770 if (MSGI(1) != 3) {
1771 scmd_printk(KERN_ERR, CURRENT_SC,
1772 "SDTR message length!=3\n");
1773 break;
1774 }
1775
1776 if (!HOSTDATA(shpnt)->synchronous)
1777 break;
1778
1779 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1780 spi_print_msg(&MSGI(0));
1781 printk("\n");
1782
1783 ticks = (MSGI(3) * 4 + 49) / 50;
1784
1785 if (syncneg) {
1786 /* negotiation in progress */
1787 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1788 ADDMSGO(MESSAGE_REJECT);
1789 scmd_printk(KERN_INFO,
1790 CURRENT_SC,
1791 "received Synchronous Data Transfer Request invalid - rejected\n");
1792 break;
1793 }
1794
1795 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1796 } else if (ticks <= 9 && MSGI(4) >= 1) {
1797 ADDMSGO(EXTENDED_MESSAGE);
1798 ADDMSGO(3);
1799 ADDMSGO(EXTENDED_SDTR);
1800 if (ticks < 4) {
1801 ticks = 4;
1802 ADDMSGO(50);
1803 } else
1804 ADDMSGO(MSGI(3));
1805
1806 if (MSGI(4) > 8)
1807 MSGI(4) = 8;
1808
1809 ADDMSGO(MSGI(4));
1810
1811 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1812 } else {
1813 /* requested SDTR is too slow, do it asynchronously */
1814 scmd_printk(KERN_INFO,
1815 CURRENT_SC,
1816 "Synchronous Data Transfer Request too slow - Rejecting\n");
1817 ADDMSGO(MESSAGE_REJECT);
1818 }
1819
1820 /* negotiation completed */
1821 SYNCNEG=2;
1822 SETRATE(SYNCRATE);
1823 }
1824 break;
1825
1826 case BUS_DEVICE_RESET:
1827 {
1828 int i;
1829
1830 for(i=0; i<8; i++) {
1831 HOSTDATA(shpnt)->syncrate[i]=0;
1832 HOSTDATA(shpnt)->syncneg[i]=0;
1833 }
1834
1835 }
1836 break;
1837
1838 case EXTENDED_MODIFY_DATA_POINTER:
1839 case EXTENDED_EXTENDED_IDENTIFY:
1840 case EXTENDED_WDTR:
1841 default:
1842 ADDMSGO(MESSAGE_REJECT);
1843 break;
1844 }
1845 break;
1846 }
1847
1848 MSGILEN=0;
1849 }
1850}
1851
1852static void msgi_end(struct Scsi_Host *shpnt)
1853{
1854 if(MSGILEN>0)
1855 scmd_printk(KERN_WARNING, CURRENT_SC,
1856 "target left before message completed (%d)\n",
1857 MSGILEN);
1858
1859 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE))
1860 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1861}
1862
1863/*
1864 * message out phase
1865 *
1866 */
1867static void msgo_init(struct Scsi_Host *shpnt)
1868{
1869 if(MSGOLEN==0) {
1870 if ((aha152x_priv(CURRENT_SC)->phase & syncneg) &&
1871 SYNCNEG == 2 && SYNCRATE == 0) {
1872 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1873 } else {
1874 scmd_printk(KERN_INFO, CURRENT_SC,
1875 "unexpected MESSAGE OUT phase; rejecting\n");
1876 ADDMSGO(MESSAGE_REJECT);
1877 }
1878 }
1879
1880}
1881
1882/*
1883 * message out phase
1884 *
1885 */
1886static void msgo_run(struct Scsi_Host *shpnt)
1887{
1888 struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
1889
1890 while(MSGO_I<MSGOLEN) {
1891 if (TESTLO(SSTAT0, SPIORDY))
1892 return;
1893
1894 if (MSGO_I==MSGOLEN-1) {
1895 /* Leave MESSAGE OUT after transfer */
1896 SETPORT(SSTAT1, CLRATNO);
1897 }
1898
1899
1900 if (MSGO(MSGO_I) & IDENTIFY_BASE)
1901 acp->phase |= identified;
1902
1903 if (MSGO(MSGO_I)==ABORT)
1904 acp->phase |= aborted;
1905
1906 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
1907 acp->phase |= resetted;
1908
1909 SETPORT(SCSIDAT, MSGO(MSGO_I++));
1910 }
1911}
1912
1913static void msgo_end(struct Scsi_Host *shpnt)
1914{
1915 if(MSGO_I<MSGOLEN) {
1916 scmd_printk(KERN_ERR, CURRENT_SC,
1917 "message sent incompletely (%d/%d)\n",
1918 MSGO_I, MSGOLEN);
1919 if(SYNCNEG==1) {
1920 scmd_printk(KERN_INFO, CURRENT_SC,
1921 "Synchronous Data Transfer Request was rejected\n");
1922 SYNCNEG=2;
1923 }
1924 }
1925
1926 MSGO_I = 0;
1927 MSGOLEN = 0;
1928}
1929
1930/*
1931 * command phase
1932 *
1933 */
1934static void cmd_init(struct Scsi_Host *shpnt)
1935{
1936 if (aha152x_priv(CURRENT_SC)->sent_command) {
1937 scmd_printk(KERN_ERR, CURRENT_SC,
1938 "command already sent\n");
1939 done(shpnt, SAM_STAT_GOOD, DID_ERROR);
1940 return;
1941 }
1942
1943 CMD_I=0;
1944}
1945
1946/*
1947 * command phase
1948 *
1949 */
1950static void cmd_run(struct Scsi_Host *shpnt)
1951{
1952 while(CMD_I<CURRENT_SC->cmd_len) {
1953 if (TESTLO(SSTAT0, SPIORDY))
1954 return;
1955
1956 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
1957 }
1958}
1959
1960static void cmd_end(struct Scsi_Host *shpnt)
1961{
1962 if(CMD_I<CURRENT_SC->cmd_len)
1963 scmd_printk(KERN_ERR, CURRENT_SC,
1964 "command sent incompletely (%d/%d)\n",
1965 CMD_I, CURRENT_SC->cmd_len);
1966 else
1967 aha152x_priv(CURRENT_SC)->sent_command++;
1968}
1969
1970/*
1971 * status phase
1972 *
1973 */
1974static void status_run(struct Scsi_Host *shpnt)
1975{
1976 if (TESTLO(SSTAT0, SPIORDY))
1977 return;
1978
1979 aha152x_priv(CURRENT_SC)->status = GETPORT(SCSIDAT);
1980
1981}
1982
1983/*
1984 * data in phase
1985 *
1986 */
1987static void datai_init(struct Scsi_Host *shpnt)
1988{
1989 SETPORT(DMACNTRL0, RSTFIFO);
1990 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
1991
1992 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
1993 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
1994
1995 SETPORT(SIMODE0, 0);
1996 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
1997
1998 DATA_LEN=0;
1999}
2000
2001static void datai_run(struct Scsi_Host *shpnt)
2002{
2003 struct aha152x_cmd_priv *acp;
2004 unsigned long the_time;
2005 int fifodata, data_count;
2006
2007 /*
2008 * loop while the phase persists or the fifos are not empty
2009 *
2010 */
2011 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2012 /* FIXME: maybe this should be done by setting up
2013 * STCNT to trigger ENSWRAP interrupt, instead of
2014 * polling for DFIFOFULL
2015 */
2016 the_time=jiffies + 100*HZ;
2017 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2018 barrier();
2019
2020 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2021 scmd_printk(KERN_ERR, CURRENT_SC, "datai timeout\n");
2022 break;
2023 }
2024
2025 if(TESTHI(DMASTAT, DFIFOFULL)) {
2026 fifodata = 128;
2027 } else {
2028 the_time=jiffies + 100*HZ;
2029 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2030 barrier();
2031
2032 if(TESTLO(SSTAT2, SEMPTY)) {
2033 scmd_printk(KERN_ERR, CURRENT_SC,
2034 "datai sempty timeout");
2035 break;
2036 }
2037
2038 fifodata = GETPORT(FIFOSTAT);
2039 }
2040
2041 acp = aha152x_priv(CURRENT_SC);
2042 if (acp->this_residual > 0) {
2043 while (fifodata > 0 && acp->this_residual > 0) {
2044 data_count = fifodata > acp->this_residual ?
2045 acp->this_residual : fifodata;
2046 fifodata -= data_count;
2047
2048 if (data_count & 1) {
2049 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2050 *acp->ptr++ = GETPORT(DATAPORT);
2051 acp->this_residual--;
2052 DATA_LEN++;
2053 SETPORT(DMACNTRL0, ENDMA);
2054 }
2055
2056 if (data_count > 1) {
2057 data_count >>= 1;
2058 insw(DATAPORT, acp->ptr, data_count);
2059 acp->ptr += 2 * data_count;
2060 acp->this_residual -= 2 * data_count;
2061 DATA_LEN += 2 * data_count;
2062 }
2063
2064 if (acp->this_residual == 0 &&
2065 !sg_is_last(acp->buffer)) {
2066 /* advance to next buffer */
2067 acp->buffer = sg_next(acp->buffer);
2068 acp->ptr = SG_ADDRESS(acp->buffer);
2069 acp->this_residual = acp->buffer->length;
2070 }
2071 }
2072 } else if (fifodata > 0) {
2073 scmd_printk(KERN_ERR, CURRENT_SC,
2074 "no buffers left for %d(%d) bytes"
2075 " (data overrun!?)\n",
2076 fifodata, GETPORT(FIFOSTAT));
2077 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2078 while(fifodata>0) {
2079 GETPORT(DATAPORT);
2080 fifodata--;
2081 DATA_LEN++;
2082 }
2083 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2084 }
2085 }
2086
2087 if(TESTLO(DMASTAT, INTSTAT) ||
2088 TESTLO(DMASTAT, DFIFOEMP) ||
2089 TESTLO(SSTAT2, SEMPTY) ||
2090 GETPORT(FIFOSTAT)>0) {
2091 /*
2092 * something went wrong, if there's something left in the fifos
2093 * or the phase didn't change
2094 */
2095 scmd_printk(KERN_ERR, CURRENT_SC,
2096 "fifos should be empty and phase should have changed\n");
2097 }
2098
2099 if(DATA_LEN!=GETSTCNT()) {
2100 scmd_printk(KERN_ERR, CURRENT_SC,
2101 "manual transfer count differs from automatic "
2102 "(count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2103 DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN,
2104 GETPORT(FIFOSTAT));
2105 mdelay(10000);
2106 }
2107}
2108
2109static void datai_end(struct Scsi_Host *shpnt)
2110{
2111 CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2112
2113 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2114 SETPORT(DMACNTRL0, 0);
2115}
2116
2117/*
2118 * data out phase
2119 *
2120 */
2121static void datao_init(struct Scsi_Host *shpnt)
2122{
2123 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2124 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2125
2126 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2127 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2128
2129 SETPORT(SIMODE0, 0);
2130 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2131
2132 DATA_LEN = scsi_get_resid(CURRENT_SC);
2133}
2134
2135static void datao_run(struct Scsi_Host *shpnt)
2136{
2137 struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
2138 unsigned long the_time;
2139 int data_count;
2140
2141 /* until phase changes or all data sent */
2142 while (TESTLO(DMASTAT, INTSTAT) && acp->this_residual > 0) {
2143 data_count = 128;
2144 if (data_count > acp->this_residual)
2145 data_count = acp->this_residual;
2146
2147 if(TESTLO(DMASTAT, DFIFOEMP)) {
2148 scmd_printk(KERN_ERR, CURRENT_SC,
2149 "datao fifo not empty (%d)",
2150 GETPORT(FIFOSTAT));
2151 break;
2152 }
2153
2154 if(data_count & 1) {
2155 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2156 SETPORT(DATAPORT, *acp->ptr++);
2157 acp->this_residual--;
2158 CMD_INC_RESID(CURRENT_SC, -1);
2159 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2160 }
2161
2162 if(data_count > 1) {
2163 data_count >>= 1;
2164 outsw(DATAPORT, acp->ptr, data_count);
2165 acp->ptr += 2 * data_count;
2166 acp->this_residual -= 2 * data_count;
2167 CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2168 }
2169
2170 if (acp->this_residual == 0 && !sg_is_last(acp->buffer)) {
2171 /* advance to next buffer */
2172 acp->buffer = sg_next(acp->buffer);
2173 acp->ptr = SG_ADDRESS(acp->buffer);
2174 acp->this_residual = acp->buffer->length;
2175 }
2176
2177 the_time=jiffies + 100*HZ;
2178 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2179 barrier();
2180
2181 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2182 scmd_printk(KERN_ERR, CURRENT_SC, "dataout timeout\n");
2183 break;
2184 }
2185 }
2186}
2187
2188static void datao_end(struct Scsi_Host *shpnt)
2189{
2190 struct aha152x_cmd_priv *acp = aha152x_priv(CURRENT_SC);
2191
2192 if(TESTLO(DMASTAT, DFIFOEMP)) {
2193 u32 datao_cnt = GETSTCNT();
2194 int datao_out = DATA_LEN - scsi_get_resid(CURRENT_SC);
2195 int done;
2196 struct scatterlist *sg = scsi_sglist(CURRENT_SC);
2197
2198 CMD_INC_RESID(CURRENT_SC, datao_out - datao_cnt);
2199
2200 done = scsi_bufflen(CURRENT_SC) - scsi_get_resid(CURRENT_SC);
2201 /* Locate the first SG entry not yet sent */
2202 while (done > 0 && !sg_is_last(sg)) {
2203 if (done < sg->length)
2204 break;
2205 done -= sg->length;
2206 sg = sg_next(sg);
2207 }
2208
2209 acp->buffer = sg;
2210 acp->ptr = SG_ADDRESS(acp->buffer) + done;
2211 acp->this_residual = acp->buffer->length - done;
2212 }
2213
2214 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2215 SETPORT(SXFRCTL0, CH1);
2216
2217 SETPORT(DMACNTRL0, 0);
2218}
2219
2220/*
2221 * figure out what state we're in
2222 *
2223 */
2224static int update_state(struct Scsi_Host *shpnt)
2225{
2226 int dataphase=0;
2227 unsigned int stat0 = GETPORT(SSTAT0);
2228 unsigned int stat1 = GETPORT(SSTAT1);
2229
2230 PREVSTATE = STATE;
2231 STATE=unknown;
2232
2233 if(stat1 & SCSIRSTI) {
2234 STATE=rsti;
2235 SETPORT(SCSISEQ,0);
2236 SETPORT(SSTAT1,SCSIRSTI);
2237 } else if (stat0 & SELDI && PREVSTATE == busfree) {
2238 STATE=seldi;
2239 } else if (stat0 & SELDO && CURRENT_SC &&
2240 (aha152x_priv(CURRENT_SC)->phase & selecting)) {
2241 STATE=seldo;
2242 } else if(stat1 & SELTO) {
2243 STATE=selto;
2244 } else if(stat1 & BUSFREE) {
2245 STATE=busfree;
2246 SETPORT(SSTAT1,BUSFREE);
2247 } else if(stat1 & SCSIPERR) {
2248 STATE=parerr;
2249 SETPORT(SSTAT1,SCSIPERR);
2250 } else if(stat1 & REQINIT) {
2251 switch(GETPORT(SCSISIG) & P_MASK) {
2252 case P_MSGI: STATE=msgi; break;
2253 case P_MSGO: STATE=msgo; break;
2254 case P_DATAO: STATE=datao; break;
2255 case P_DATAI: STATE=datai; break;
2256 case P_STATUS: STATE=status; break;
2257 case P_CMD: STATE=cmd; break;
2258 }
2259 dataphase=1;
2260 }
2261
2262 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2263 scmd_printk(KERN_INFO, CURRENT_SC, "reselection missed?");
2264 }
2265
2266 if(STATE!=PREVSTATE) {
2267 LASTSTATE=PREVSTATE;
2268 }
2269
2270 return dataphase;
2271}
2272
2273/*
2274 * handle parity error
2275 *
2276 * FIXME: in which phase?
2277 *
2278 */
2279static void parerr_run(struct Scsi_Host *shpnt)
2280{
2281 scmd_printk(KERN_ERR, CURRENT_SC, "parity error\n");
2282 done(shpnt, SAM_STAT_GOOD, DID_PARITY);
2283}
2284
2285/*
2286 * handle reset in
2287 *
2288 */
2289static void rsti_run(struct Scsi_Host *shpnt)
2290{
2291 struct scsi_cmnd *ptr;
2292
2293 shost_printk(KERN_NOTICE, shpnt, "scsi reset in\n");
2294
2295 ptr=DISCONNECTED_SC;
2296 while(ptr) {
2297 struct scsi_cmnd *next = SCNEXT(ptr);
2298
2299 if (!ptr->device->soft_reset) {
2300 remove_SC(&DISCONNECTED_SC, ptr);
2301
2302 kfree(ptr->host_scribble);
2303 ptr->host_scribble=NULL;
2304
2305 set_host_byte(ptr, DID_RESET);
2306 aha152x_scsi_done(ptr);
2307 }
2308
2309 ptr = next;
2310 }
2311
2312 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2313 done(shpnt, SAM_STAT_GOOD, DID_RESET);
2314}
2315
2316
2317/*
2318 * bottom-half handler
2319 *
2320 */
2321static void is_complete(struct Scsi_Host *shpnt)
2322{
2323 int dataphase;
2324 unsigned long flags;
2325 int pending;
2326
2327 if(!shpnt)
2328 return;
2329
2330 DO_LOCK(flags);
2331
2332 if( HOSTDATA(shpnt)->service==0 ) {
2333 DO_UNLOCK(flags);
2334 return;
2335 }
2336
2337 HOSTDATA(shpnt)->service = 0;
2338
2339 if(HOSTDATA(shpnt)->in_intr) {
2340 DO_UNLOCK(flags);
2341 /* aha152x_error never returns.. */
2342 aha152x_error(shpnt, "bottom-half already running!?");
2343 }
2344 HOSTDATA(shpnt)->in_intr++;
2345
2346 /*
2347 * loop while there are interrupt conditions pending
2348 *
2349 */
2350 do {
2351 unsigned long start = jiffies;
2352 DO_UNLOCK(flags);
2353
2354 dataphase=update_state(shpnt);
2355
2356 /*
2357 * end previous state
2358 *
2359 */
2360 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2361 states[PREVSTATE].end(shpnt);
2362
2363 /*
2364 * disable SPIO mode if previous phase used it
2365 * and this one doesn't
2366 *
2367 */
2368 if(states[PREVSTATE].spio && !states[STATE].spio) {
2369 SETPORT(SXFRCTL0, CH1);
2370 SETPORT(DMACNTRL0, 0);
2371 if(CURRENT_SC)
2372 aha152x_priv(CURRENT_SC)->phase &= ~spiordy;
2373 }
2374
2375 /*
2376 * accept current dataphase phase
2377 *
2378 */
2379 if(dataphase) {
2380 SETPORT(SSTAT0, REQINIT);
2381 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2382 SETPORT(SSTAT1, PHASECHG);
2383 }
2384
2385 /*
2386 * enable SPIO mode if previous didn't use it
2387 * and this one does
2388 *
2389 */
2390 if(!states[PREVSTATE].spio && states[STATE].spio) {
2391 SETPORT(DMACNTRL0, 0);
2392 SETPORT(SXFRCTL0, CH1|SPIOEN);
2393 if(CURRENT_SC)
2394 aha152x_priv(CURRENT_SC)->phase |= spiordy;
2395 }
2396
2397 /*
2398 * initialize for new state
2399 *
2400 */
2401 if(PREVSTATE!=STATE && states[STATE].init)
2402 states[STATE].init(shpnt);
2403
2404 /*
2405 * handle current state
2406 *
2407 */
2408 if(states[STATE].run)
2409 states[STATE].run(shpnt);
2410 else
2411 scmd_printk(KERN_ERR, CURRENT_SC,
2412 "unexpected state (%x)\n", STATE);
2413
2414 /*
2415 * setup controller to interrupt on
2416 * the next expected condition and
2417 * loop if it's already there
2418 *
2419 */
2420 DO_LOCK(flags);
2421 pending=setup_expected_interrupts(shpnt);
2422#if defined(AHA152X_STAT)
2423 HOSTDATA(shpnt)->count[STATE]++;
2424 if(PREVSTATE!=STATE)
2425 HOSTDATA(shpnt)->count_trans[STATE]++;
2426 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2427#endif
2428
2429 } while(pending);
2430
2431 /*
2432 * enable interrupts and leave bottom-half
2433 *
2434 */
2435 HOSTDATA(shpnt)->in_intr--;
2436 SETBITS(DMACNTRL0, INTEN);
2437 DO_UNLOCK(flags);
2438}
2439
2440
2441/*
2442 * Dump the current driver status and panic
2443 */
2444static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2445{
2446 shost_printk(KERN_EMERG, shpnt, "%s\n", msg);
2447 show_queues(shpnt);
2448 panic("aha152x panic\n");
2449}
2450
2451/*
2452 * display enabled interrupts
2453 */
2454static void disp_enintr(struct Scsi_Host *shpnt)
2455{
2456 int s0, s1;
2457
2458 s0 = GETPORT(SIMODE0);
2459 s1 = GETPORT(SIMODE1);
2460
2461 shost_printk(KERN_DEBUG, shpnt,
2462 "enabled interrupts (%s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
2463 (s0 & ENSELDO) ? "ENSELDO " : "",
2464 (s0 & ENSELDI) ? "ENSELDI " : "",
2465 (s0 & ENSELINGO) ? "ENSELINGO " : "",
2466 (s0 & ENSWRAP) ? "ENSWRAP " : "",
2467 (s0 & ENSDONE) ? "ENSDONE " : "",
2468 (s0 & ENSPIORDY) ? "ENSPIORDY " : "",
2469 (s0 & ENDMADONE) ? "ENDMADONE " : "",
2470 (s1 & ENSELTIMO) ? "ENSELTIMO " : "",
2471 (s1 & ENATNTARG) ? "ENATNTARG " : "",
2472 (s1 & ENPHASEMIS) ? "ENPHASEMIS " : "",
2473 (s1 & ENBUSFREE) ? "ENBUSFREE " : "",
2474 (s1 & ENSCSIPERR) ? "ENSCSIPERR " : "",
2475 (s1 & ENPHASECHG) ? "ENPHASECHG " : "",
2476 (s1 & ENREQINIT) ? "ENREQINIT " : "");
2477}
2478
2479/*
2480 * Show the command data of a command
2481 */
2482static void show_command(struct scsi_cmnd *ptr)
2483{
2484 const int phase = aha152x_priv(ptr)->phase;
2485
2486 scsi_print_command(ptr);
2487 scmd_printk(KERN_DEBUG, ptr,
2488 "request_bufflen=%d; resid=%d; "
2489 "phase |%s%s%s%s%s%s%s%s%s; next=0x%p",
2490 scsi_bufflen(ptr), scsi_get_resid(ptr),
2491 phase & not_issued ? "not issued|" : "",
2492 phase & selecting ? "selecting|" : "",
2493 phase & identified ? "identified|" : "",
2494 phase & disconnected ? "disconnected|" : "",
2495 phase & completed ? "completed|" : "",
2496 phase & spiordy ? "spiordy|" : "",
2497 phase & syncneg ? "syncneg|" : "",
2498 phase & aborted ? "aborted|" : "",
2499 phase & resetted ? "resetted|" : "",
2500 SCDATA(ptr) ? SCNEXT(ptr) : NULL);
2501}
2502
2503/*
2504 * Dump the queued data
2505 */
2506static void show_queues(struct Scsi_Host *shpnt)
2507{
2508 struct scsi_cmnd *ptr;
2509 unsigned long flags;
2510
2511 DO_LOCK(flags);
2512 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2513 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2514 show_command(ptr);
2515 DO_UNLOCK(flags);
2516
2517 printk(KERN_DEBUG "current_SC:\n");
2518 if (CURRENT_SC)
2519 show_command(CURRENT_SC);
2520 else
2521 printk(KERN_DEBUG "none\n");
2522
2523 printk(KERN_DEBUG "disconnected_SC:\n");
2524 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2525 show_command(ptr);
2526
2527 disp_enintr(shpnt);
2528}
2529
2530static void get_command(struct seq_file *m, struct scsi_cmnd * ptr)
2531{
2532 struct aha152x_cmd_priv *acp = aha152x_priv(ptr);
2533 const int phase = acp->phase;
2534 int i;
2535
2536 seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
2537 ptr, ptr->device->id, (u8)ptr->device->lun);
2538
2539 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2540 seq_printf(m, "0x%02x ", ptr->cmnd[i]);
2541
2542 seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
2543 scsi_get_resid(ptr), acp->this_residual,
2544 sg_nents(acp->buffer) - 1);
2545
2546 if (phase & not_issued)
2547 seq_puts(m, "not issued|");
2548 if (phase & selecting)
2549 seq_puts(m, "selecting|");
2550 if (phase & disconnected)
2551 seq_puts(m, "disconnected|");
2552 if (phase & aborted)
2553 seq_puts(m, "aborted|");
2554 if (phase & identified)
2555 seq_puts(m, "identified|");
2556 if (phase & completed)
2557 seq_puts(m, "completed|");
2558 if (phase & spiordy)
2559 seq_puts(m, "spiordy|");
2560 if (phase & syncneg)
2561 seq_puts(m, "syncneg|");
2562 seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
2563}
2564
2565static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
2566{
2567 int s;
2568
2569 seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
2570
2571 s = GETPORT(SCSISEQ);
2572 seq_puts(m, "SCSISEQ( ");
2573 if (s & TEMODEO)
2574 seq_puts(m, "TARGET MODE ");
2575 if (s & ENSELO)
2576 seq_puts(m, "SELO ");
2577 if (s & ENSELI)
2578 seq_puts(m, "SELI ");
2579 if (s & ENRESELI)
2580 seq_puts(m, "RESELI ");
2581 if (s & ENAUTOATNO)
2582 seq_puts(m, "AUTOATNO ");
2583 if (s & ENAUTOATNI)
2584 seq_puts(m, "AUTOATNI ");
2585 if (s & ENAUTOATNP)
2586 seq_puts(m, "AUTOATNP ");
2587 if (s & SCSIRSTO)
2588 seq_puts(m, "SCSIRSTO ");
2589 seq_puts(m, ");");
2590
2591 seq_puts(m, " SCSISIG(");
2592 s = GETPORT(SCSISIG);
2593 switch (s & P_MASK) {
2594 case P_DATAO:
2595 seq_puts(m, "DATA OUT");
2596 break;
2597 case P_DATAI:
2598 seq_puts(m, "DATA IN");
2599 break;
2600 case P_CMD:
2601 seq_puts(m, "COMMAND");
2602 break;
2603 case P_STATUS:
2604 seq_puts(m, "STATUS");
2605 break;
2606 case P_MSGO:
2607 seq_puts(m, "MESSAGE OUT");
2608 break;
2609 case P_MSGI:
2610 seq_puts(m, "MESSAGE IN");
2611 break;
2612 default:
2613 seq_puts(m, "*invalid*");
2614 break;
2615 }
2616
2617 seq_puts(m, "); ");
2618
2619 seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2620
2621 seq_puts(m, "SSTAT( ");
2622 s = GETPORT(SSTAT0);
2623 if (s & TARGET)
2624 seq_puts(m, "TARGET ");
2625 if (s & SELDO)
2626 seq_puts(m, "SELDO ");
2627 if (s & SELDI)
2628 seq_puts(m, "SELDI ");
2629 if (s & SELINGO)
2630 seq_puts(m, "SELINGO ");
2631 if (s & SWRAP)
2632 seq_puts(m, "SWRAP ");
2633 if (s & SDONE)
2634 seq_puts(m, "SDONE ");
2635 if (s & SPIORDY)
2636 seq_puts(m, "SPIORDY ");
2637 if (s & DMADONE)
2638 seq_puts(m, "DMADONE ");
2639
2640 s = GETPORT(SSTAT1);
2641 if (s & SELTO)
2642 seq_puts(m, "SELTO ");
2643 if (s & ATNTARG)
2644 seq_puts(m, "ATNTARG ");
2645 if (s & SCSIRSTI)
2646 seq_puts(m, "SCSIRSTI ");
2647 if (s & PHASEMIS)
2648 seq_puts(m, "PHASEMIS ");
2649 if (s & BUSFREE)
2650 seq_puts(m, "BUSFREE ");
2651 if (s & SCSIPERR)
2652 seq_puts(m, "SCSIPERR ");
2653 if (s & PHASECHG)
2654 seq_puts(m, "PHASECHG ");
2655 if (s & REQINIT)
2656 seq_puts(m, "REQINIT ");
2657 seq_puts(m, "); ");
2658
2659
2660 seq_puts(m, "SSTAT( ");
2661
2662 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2663
2664 if (s & TARGET)
2665 seq_puts(m, "TARGET ");
2666 if (s & SELDO)
2667 seq_puts(m, "SELDO ");
2668 if (s & SELDI)
2669 seq_puts(m, "SELDI ");
2670 if (s & SELINGO)
2671 seq_puts(m, "SELINGO ");
2672 if (s & SWRAP)
2673 seq_puts(m, "SWRAP ");
2674 if (s & SDONE)
2675 seq_puts(m, "SDONE ");
2676 if (s & SPIORDY)
2677 seq_puts(m, "SPIORDY ");
2678 if (s & DMADONE)
2679 seq_puts(m, "DMADONE ");
2680
2681 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2682
2683 if (s & SELTO)
2684 seq_puts(m, "SELTO ");
2685 if (s & ATNTARG)
2686 seq_puts(m, "ATNTARG ");
2687 if (s & SCSIRSTI)
2688 seq_puts(m, "SCSIRSTI ");
2689 if (s & PHASEMIS)
2690 seq_puts(m, "PHASEMIS ");
2691 if (s & BUSFREE)
2692 seq_puts(m, "BUSFREE ");
2693 if (s & SCSIPERR)
2694 seq_puts(m, "SCSIPERR ");
2695 if (s & PHASECHG)
2696 seq_puts(m, "PHASECHG ");
2697 if (s & REQINIT)
2698 seq_puts(m, "REQINIT ");
2699 seq_puts(m, "); ");
2700
2701 seq_puts(m, "SXFRCTL0( ");
2702
2703 s = GETPORT(SXFRCTL0);
2704 if (s & SCSIEN)
2705 seq_puts(m, "SCSIEN ");
2706 if (s & DMAEN)
2707 seq_puts(m, "DMAEN ");
2708 if (s & CH1)
2709 seq_puts(m, "CH1 ");
2710 if (s & CLRSTCNT)
2711 seq_puts(m, "CLRSTCNT ");
2712 if (s & SPIOEN)
2713 seq_puts(m, "SPIOEN ");
2714 if (s & CLRCH1)
2715 seq_puts(m, "CLRCH1 ");
2716 seq_puts(m, "); ");
2717
2718 seq_puts(m, "SIGNAL( ");
2719
2720 s = GETPORT(SCSISIG);
2721 if (s & SIG_ATNI)
2722 seq_puts(m, "ATNI ");
2723 if (s & SIG_SELI)
2724 seq_puts(m, "SELI ");
2725 if (s & SIG_BSYI)
2726 seq_puts(m, "BSYI ");
2727 if (s & SIG_REQI)
2728 seq_puts(m, "REQI ");
2729 if (s & SIG_ACKI)
2730 seq_puts(m, "ACKI ");
2731 seq_puts(m, "); ");
2732
2733 seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
2734
2735 seq_printf(m, "STCNT(%d), ", GETSTCNT());
2736
2737 seq_puts(m, "SSTAT2( ");
2738
2739 s = GETPORT(SSTAT2);
2740 if (s & SOFFSET)
2741 seq_puts(m, "SOFFSET ");
2742 if (s & SEMPTY)
2743 seq_puts(m, "SEMPTY ");
2744 if (s & SFULL)
2745 seq_puts(m, "SFULL ");
2746 seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
2747
2748 s = GETPORT(SSTAT3);
2749 seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2750
2751 seq_puts(m, "SSTAT4( ");
2752 s = GETPORT(SSTAT4);
2753 if (s & SYNCERR)
2754 seq_puts(m, "SYNCERR ");
2755 if (s & FWERR)
2756 seq_puts(m, "FWERR ");
2757 if (s & FRERR)
2758 seq_puts(m, "FRERR ");
2759 seq_puts(m, "); ");
2760
2761 seq_puts(m, "DMACNTRL0( ");
2762 s = GETPORT(DMACNTRL0);
2763 seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
2764 seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
2765 seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
2766 if (s & ENDMA)
2767 seq_puts(m, "ENDMA ");
2768 if (s & INTEN)
2769 seq_puts(m, "INTEN ");
2770 if (s & RSTFIFO)
2771 seq_puts(m, "RSTFIFO ");
2772 if (s & SWINT)
2773 seq_puts(m, "SWINT ");
2774 seq_puts(m, "); ");
2775
2776 seq_puts(m, "DMASTAT( ");
2777 s = GETPORT(DMASTAT);
2778 if (s & ATDONE)
2779 seq_puts(m, "ATDONE ");
2780 if (s & WORDRDY)
2781 seq_puts(m, "WORDRDY ");
2782 if (s & DFIFOFULL)
2783 seq_puts(m, "DFIFOFULL ");
2784 if (s & DFIFOEMP)
2785 seq_puts(m, "DFIFOEMP ");
2786 seq_puts(m, ")\n");
2787
2788 seq_puts(m, "enabled interrupts( ");
2789
2790 s = GETPORT(SIMODE0);
2791 if (s & ENSELDO)
2792 seq_puts(m, "ENSELDO ");
2793 if (s & ENSELDI)
2794 seq_puts(m, "ENSELDI ");
2795 if (s & ENSELINGO)
2796 seq_puts(m, "ENSELINGO ");
2797 if (s & ENSWRAP)
2798 seq_puts(m, "ENSWRAP ");
2799 if (s & ENSDONE)
2800 seq_puts(m, "ENSDONE ");
2801 if (s & ENSPIORDY)
2802 seq_puts(m, "ENSPIORDY ");
2803 if (s & ENDMADONE)
2804 seq_puts(m, "ENDMADONE ");
2805
2806 s = GETPORT(SIMODE1);
2807 if (s & ENSELTIMO)
2808 seq_puts(m, "ENSELTIMO ");
2809 if (s & ENATNTARG)
2810 seq_puts(m, "ENATNTARG ");
2811 if (s & ENPHASEMIS)
2812 seq_puts(m, "ENPHASEMIS ");
2813 if (s & ENBUSFREE)
2814 seq_puts(m, "ENBUSFREE ");
2815 if (s & ENSCSIPERR)
2816 seq_puts(m, "ENSCSIPERR ");
2817 if (s & ENPHASECHG)
2818 seq_puts(m, "ENPHASECHG ");
2819 if (s & ENREQINIT)
2820 seq_puts(m, "ENREQINIT ");
2821 seq_puts(m, ")\n");
2822}
2823
2824static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
2825{
2826 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
2827 return -EINVAL;
2828
2829#if defined(AHA152X_STAT)
2830 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
2831 int i;
2832
2833 HOSTDATA(shpnt)->total_commands=0;
2834 HOSTDATA(shpnt)->disconnections=0;
2835 HOSTDATA(shpnt)->busfree_without_any_action=0;
2836 HOSTDATA(shpnt)->busfree_without_old_command=0;
2837 HOSTDATA(shpnt)->busfree_without_new_command=0;
2838 HOSTDATA(shpnt)->busfree_without_done_command=0;
2839 HOSTDATA(shpnt)->busfree_with_check_condition=0;
2840 for (i = idle; i<maxstate; i++) {
2841 HOSTDATA(shpnt)->count[i]=0;
2842 HOSTDATA(shpnt)->count_trans[i]=0;
2843 HOSTDATA(shpnt)->time[i]=0;
2844 }
2845
2846 shost_printk(KERN_INFO, shpnt, "aha152x: stats reset.\n");
2847
2848 } else
2849#endif
2850 {
2851 return -EINVAL;
2852 }
2853
2854
2855 return length;
2856}
2857
2858static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
2859{
2860 int i;
2861 struct scsi_cmnd *ptr;
2862 unsigned long flags;
2863
2864 seq_puts(m, AHA152X_REVID "\n");
2865
2866 seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
2867 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
2868 seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
2869 seq_printf(m, "disconnection/reconnection %s\n",
2870 RECONNECT ? "enabled" : "disabled");
2871 seq_printf(m, "parity checking %s\n",
2872 PARITY ? "enabled" : "disabled");
2873 seq_printf(m, "synchronous transfers %s\n",
2874 SYNCHRONOUS ? "enabled" : "disabled");
2875 seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
2876
2877 if(SYNCHRONOUS) {
2878 seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
2879 for (i = 0; i < 8; i++)
2880 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
2881 seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
2882 i,
2883 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
2884 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
2885 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
2886 }
2887 seq_puts(m, "\nqueue status:\n");
2888 DO_LOCK(flags);
2889 if (ISSUE_SC) {
2890 seq_puts(m, "not yet issued commands:\n");
2891 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2892 get_command(m, ptr);
2893 } else
2894 seq_puts(m, "no not yet issued commands\n");
2895 DO_UNLOCK(flags);
2896
2897 if (CURRENT_SC) {
2898 seq_puts(m, "current command:\n");
2899 get_command(m, CURRENT_SC);
2900 } else
2901 seq_puts(m, "no current command\n");
2902
2903 if (DISCONNECTED_SC) {
2904 seq_puts(m, "disconnected commands:\n");
2905 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
2906 get_command(m, ptr);
2907 } else
2908 seq_puts(m, "no disconnected commands\n");
2909
2910 get_ports(m, shpnt);
2911
2912#if defined(AHA152X_STAT)
2913 seq_printf(m, "statistics:\n"
2914 "total commands: %d\n"
2915 "disconnections: %d\n"
2916 "busfree with check condition: %d\n"
2917 "busfree without old command: %d\n"
2918 "busfree without new command: %d\n"
2919 "busfree without done command: %d\n"
2920 "busfree without any action: %d\n"
2921 "state "
2922 "transitions "
2923 "count "
2924 "time\n",
2925 HOSTDATA(shpnt)->total_commands,
2926 HOSTDATA(shpnt)->disconnections,
2927 HOSTDATA(shpnt)->busfree_with_check_condition,
2928 HOSTDATA(shpnt)->busfree_without_old_command,
2929 HOSTDATA(shpnt)->busfree_without_new_command,
2930 HOSTDATA(shpnt)->busfree_without_done_command,
2931 HOSTDATA(shpnt)->busfree_without_any_action);
2932 for(i=0; i<maxstate; i++) {
2933 seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
2934 states[i].name,
2935 HOSTDATA(shpnt)->count_trans[i],
2936 HOSTDATA(shpnt)->count[i],
2937 HOSTDATA(shpnt)->time[i]);
2938 }
2939#endif
2940 return 0;
2941}
2942
2943static int aha152x_adjust_queue(struct scsi_device *device)
2944{
2945 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
2946 return 0;
2947}
2948
2949static const struct scsi_host_template aha152x_driver_template = {
2950 .module = THIS_MODULE,
2951 .name = AHA152X_REVID,
2952 .proc_name = "aha152x",
2953 .show_info = aha152x_show_info,
2954 .write_info = aha152x_set_info,
2955 .queuecommand = aha152x_queue,
2956 .eh_abort_handler = aha152x_abort,
2957 .eh_device_reset_handler = aha152x_device_reset,
2958 .eh_bus_reset_handler = aha152x_bus_reset,
2959 .bios_param = aha152x_biosparam,
2960 .can_queue = 1,
2961 .this_id = 7,
2962 .sg_tablesize = SG_ALL,
2963 .dma_boundary = PAGE_SIZE - 1,
2964 .slave_alloc = aha152x_adjust_queue,
2965 .cmd_size = sizeof(struct aha152x_cmd_priv),
2966};
2967
2968#if !defined(AHA152X_PCMCIA)
2969static int setup_count;
2970static struct aha152x_setup setup[2];
2971
2972/* possible i/o addresses for the AIC-6260; default first */
2973static unsigned short ports[] = { 0x340, 0x140 };
2974
2975#if !defined(SKIP_BIOSTEST)
2976/* possible locations for the Adaptec BIOS; defaults first */
2977static unsigned int addresses[] =
2978{
2979 0xdc000, /* default first */
2980 0xc8000,
2981 0xcc000,
2982 0xd0000,
2983 0xd4000,
2984 0xd8000,
2985 0xe0000,
2986 0xeb800, /* VTech Platinum SMP */
2987 0xf0000,
2988};
2989
2990/* signatures for various AIC-6[23]60 based controllers.
2991 The point in detecting signatures is to avoid useless and maybe
2992 harmful probes on ports. I'm not sure that all listed boards pass
2993 auto-configuration. For those which fail the BIOS signature is
2994 obsolete, because user intervention to supply the configuration is
2995 needed anyway. May be an information whether or not the BIOS supports
2996 extended translation could be also useful here. */
2997static struct signature {
2998 unsigned char *signature;
2999 int sig_offset;
3000 int sig_length;
3001} signatures[] =
3002{
3003 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3004 /* Adaptec 152x */
3005 { "Adaptec AHA-1520B", 0x000b, 17 },
3006 /* Adaptec 152x rev B */
3007 { "Adaptec AHA-1520B", 0x0026, 17 },
3008 /* Iomega Jaz Jet ISA (AIC6370Q) */
3009 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3010 /* on-board controller */
3011 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3012 /* on-board controller */
3013 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3014 /* on-board controller */
3015 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3016 /* on-board controller */
3017 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3018 /* ScsiPro-Controller */
3019 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3020 /* Gigabyte Local-Bus-SCSI */
3021 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3022 /* Adaptec 282x */
3023 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3024 /* IBM Thinkpad Dock II */
3025 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3026 /* IBM Thinkpad Dock II SCSI */
3027 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3028 /* DTC 3520A ISA SCSI */
3029};
3030#endif /* !SKIP_BIOSTEST */
3031
3032/*
3033 * Test, if port_base is valid.
3034 *
3035 */
3036static int aha152x_porttest(int io_port)
3037{
3038 int i;
3039
3040 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3041 for (i = 0; i < 16; i++)
3042 SETPORT(io_port + O_STACK, i);
3043
3044 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3045 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3046 ;
3047
3048 return (i == 16);
3049}
3050
3051static int tc1550_porttest(int io_port)
3052{
3053 int i;
3054
3055 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3056 for (i = 0; i < 16; i++)
3057 SETPORT(io_port + O_STACK, i);
3058
3059 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3060 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3061 ;
3062
3063 return (i == 16);
3064}
3065
3066
3067static int checksetup(struct aha152x_setup *setup)
3068{
3069 int i;
3070 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3071 ;
3072
3073 if (i == ARRAY_SIZE(ports))
3074 return 0;
3075
3076 if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3077 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3078 return 0;
3079 }
3080
3081 if( aha152x_porttest(setup->io_port) ) {
3082 setup->tc1550=0;
3083 } else if( tc1550_porttest(setup->io_port) ) {
3084 setup->tc1550=1;
3085 } else {
3086 release_region(setup->io_port, IO_RANGE);
3087 return 0;
3088 }
3089
3090 release_region(setup->io_port, IO_RANGE);
3091
3092 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3093 return 0;
3094
3095 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3096 return 0;
3097
3098 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3099 return 0;
3100
3101 if ((setup->parity < 0) || (setup->parity > 1))
3102 return 0;
3103
3104 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3105 return 0;
3106
3107 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3108 return 0;
3109
3110
3111 return 1;
3112}
3113
3114
3115static int __init aha152x_init(void)
3116{
3117 int i, j, ok;
3118#if defined(AUTOCONF)
3119 aha152x_config conf;
3120#endif
3121#ifdef __ISAPNP__
3122 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3123#endif
3124
3125 if ( setup_count ) {
3126 printk(KERN_INFO "aha152x: processing commandline: ");
3127
3128 for (i = 0; i<setup_count; i++) {
3129 if (!checksetup(&setup[i])) {
3130 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3131 printk(KERN_ERR "aha152x: invalid line\n");
3132 }
3133 }
3134 printk("ok\n");
3135 }
3136
3137#if defined(SETUP0)
3138 if (setup_count < ARRAY_SIZE(setup)) {
3139 struct aha152x_setup override = SETUP0;
3140
3141 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3142 if (!checksetup(&override)) {
3143 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3144 override.io_port,
3145 override.irq,
3146 override.scsiid,
3147 override.reconnect,
3148 override.parity,
3149 override.synchronous,
3150 override.delay,
3151 override.ext_trans);
3152 } else
3153 setup[setup_count++] = override;
3154 }
3155 }
3156#endif
3157
3158#if defined(SETUP1)
3159 if (setup_count < ARRAY_SIZE(setup)) {
3160 struct aha152x_setup override = SETUP1;
3161
3162 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3163 if (!checksetup(&override)) {
3164 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3165 override.io_port,
3166 override.irq,
3167 override.scsiid,
3168 override.reconnect,
3169 override.parity,
3170 override.synchronous,
3171 override.delay,
3172 override.ext_trans);
3173 } else
3174 setup[setup_count++] = override;
3175 }
3176 }
3177#endif
3178
3179#if defined(MODULE)
3180 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3181 if(aha152x[0]!=0) {
3182 setup[setup_count].conf = "";
3183 setup[setup_count].io_port = aha152x[0];
3184 setup[setup_count].irq = aha152x[1];
3185 setup[setup_count].scsiid = aha152x[2];
3186 setup[setup_count].reconnect = aha152x[3];
3187 setup[setup_count].parity = aha152x[4];
3188 setup[setup_count].synchronous = aha152x[5];
3189 setup[setup_count].delay = aha152x[6];
3190 setup[setup_count].ext_trans = aha152x[7];
3191 } else if (io[0] != 0 || irq[0] != 0) {
3192 if(io[0]!=0) setup[setup_count].io_port = io[0];
3193 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3194
3195 setup[setup_count].scsiid = scsiid[0];
3196 setup[setup_count].reconnect = reconnect[0];
3197 setup[setup_count].parity = parity[0];
3198 setup[setup_count].synchronous = sync[0];
3199 setup[setup_count].delay = delay[0];
3200 setup[setup_count].ext_trans = exttrans[0];
3201 }
3202
3203 if (checksetup(&setup[setup_count]))
3204 setup_count++;
3205 else
3206 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",
3207 setup[setup_count].io_port,
3208 setup[setup_count].irq,
3209 setup[setup_count].scsiid,
3210 setup[setup_count].reconnect,
3211 setup[setup_count].parity,
3212 setup[setup_count].synchronous,
3213 setup[setup_count].delay,
3214 setup[setup_count].ext_trans);
3215 }
3216
3217 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3218 if(aha152x1[0]!=0) {
3219 setup[setup_count].conf = "";
3220 setup[setup_count].io_port = aha152x1[0];
3221 setup[setup_count].irq = aha152x1[1];
3222 setup[setup_count].scsiid = aha152x1[2];
3223 setup[setup_count].reconnect = aha152x1[3];
3224 setup[setup_count].parity = aha152x1[4];
3225 setup[setup_count].synchronous = aha152x1[5];
3226 setup[setup_count].delay = aha152x1[6];
3227 setup[setup_count].ext_trans = aha152x1[7];
3228 } else if (io[1] != 0 || irq[1] != 0) {
3229 if(io[1]!=0) setup[setup_count].io_port = io[1];
3230 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3231
3232 setup[setup_count].scsiid = scsiid[1];
3233 setup[setup_count].reconnect = reconnect[1];
3234 setup[setup_count].parity = parity[1];
3235 setup[setup_count].synchronous = sync[1];
3236 setup[setup_count].delay = delay[1];
3237 setup[setup_count].ext_trans = exttrans[1];
3238 }
3239 if (checksetup(&setup[setup_count]))
3240 setup_count++;
3241 else
3242 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",
3243 setup[setup_count].io_port,
3244 setup[setup_count].irq,
3245 setup[setup_count].scsiid,
3246 setup[setup_count].reconnect,
3247 setup[setup_count].parity,
3248 setup[setup_count].synchronous,
3249 setup[setup_count].delay,
3250 setup[setup_count].ext_trans);
3251 }
3252#endif
3253
3254#ifdef __ISAPNP__
3255 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3256 while ( setup_count<ARRAY_SIZE(setup) &&
3257 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3258 if (pnp_device_attach(dev) < 0)
3259 continue;
3260
3261 if (pnp_activate_dev(dev) < 0) {
3262 pnp_device_detach(dev);
3263 continue;
3264 }
3265
3266 if (!pnp_port_valid(dev, 0)) {
3267 pnp_device_detach(dev);
3268 continue;
3269 }
3270
3271 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3272 pnp_device_detach(dev);
3273 continue;
3274 }
3275
3276 setup[setup_count].io_port = pnp_port_start(dev, 0);
3277 setup[setup_count].irq = pnp_irq(dev, 0);
3278 setup[setup_count].scsiid = 7;
3279 setup[setup_count].reconnect = 1;
3280 setup[setup_count].parity = 1;
3281 setup[setup_count].synchronous = 1;
3282 setup[setup_count].delay = DELAY_DEFAULT;
3283 setup[setup_count].ext_trans = 0;
3284#if defined(__ISAPNP__)
3285 pnpdev[setup_count] = dev;
3286#endif
3287 printk (KERN_INFO
3288 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3289 setup[setup_count].io_port, setup[setup_count].irq);
3290 setup_count++;
3291 }
3292 }
3293#endif
3294
3295#if defined(AUTOCONF)
3296 if (setup_count<ARRAY_SIZE(setup)) {
3297#if !defined(SKIP_BIOSTEST)
3298 ok = 0;
3299 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3300 void __iomem *p = ioremap(addresses[i], 0x4000);
3301 if (!p)
3302 continue;
3303 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3304 ok = check_signature(p + signatures[j].sig_offset,
3305 signatures[j].signature, signatures[j].sig_length);
3306 iounmap(p);
3307 }
3308 if (!ok && setup_count == 0)
3309 return -ENODEV;
3310
3311 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3312#else
3313 printk(KERN_INFO "aha152x: ");
3314#endif /* !SKIP_BIOSTEST */
3315
3316 ok = 0;
3317 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3318 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3319 continue;
3320
3321 if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3322 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3323 continue;
3324 }
3325
3326 if (aha152x_porttest(ports[i])) {
3327 setup[setup_count].tc1550 = 0;
3328
3329 conf.cf_port =
3330 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3331 } else if (tc1550_porttest(ports[i])) {
3332 setup[setup_count].tc1550 = 1;
3333
3334 conf.cf_port =
3335 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3336 } else {
3337 release_region(ports[i], IO_RANGE);
3338 continue;
3339 }
3340
3341 release_region(ports[i], IO_RANGE);
3342
3343 ok++;
3344 setup[setup_count].io_port = ports[i];
3345 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3346 setup[setup_count].scsiid = conf.cf_id;
3347 setup[setup_count].reconnect = conf.cf_tardisc;
3348 setup[setup_count].parity = !conf.cf_parity;
3349 setup[setup_count].synchronous = conf.cf_syncneg;
3350 setup[setup_count].delay = DELAY_DEFAULT;
3351 setup[setup_count].ext_trans = 0;
3352 setup_count++;
3353
3354 }
3355
3356 if (ok)
3357 printk("auto configuration: ok, ");
3358 }
3359#endif
3360
3361 printk("%d controller(s) configured\n", setup_count);
3362
3363 for (i=0; i<setup_count; i++) {
3364 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3365 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3366
3367 if( !shpnt ) {
3368 release_region(setup[i].io_port, IO_RANGE);
3369#if defined(__ISAPNP__)
3370 } else if( pnpdev[i] ) {
3371 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3372 pnpdev[i]=NULL;
3373#endif
3374 }
3375 } else {
3376 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3377 }
3378
3379#if defined(__ISAPNP__)
3380 if( pnpdev[i] )
3381 pnp_device_detach(pnpdev[i]);
3382#endif
3383 }
3384
3385 return 0;
3386}
3387
3388static void __exit aha152x_exit(void)
3389{
3390 struct aha152x_hostdata *hd, *tmp;
3391
3392 list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3393 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3394
3395 aha152x_release(shost);
3396 }
3397}
3398
3399module_init(aha152x_init);
3400module_exit(aha152x_exit);
3401
3402#if !defined(MODULE)
3403static int __init aha152x_setup(char *str)
3404{
3405 int ints[10];
3406
3407 get_options(str, ARRAY_SIZE(ints), ints);
3408
3409 if(setup_count>=ARRAY_SIZE(setup)) {
3410 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3411 return 1;
3412 }
3413
3414 setup[setup_count].conf = str;
3415 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3416 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3417 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3418 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3419 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3420 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3421 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3422 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3423 if (ints[0] > 8)
3424 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3425 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3426 else
3427 setup_count++;
3428
3429 return 1;
3430}
3431__setup("aha152x=", aha152x_setup);
3432#endif
3433
3434#endif /* !AHA152X_PCMCIA */
1/* aha152x.c -- Adaptec AHA-152x driver
2 * Author: Jürgen E. Fischer, fischer@norbit.de
3 * Copyright 1993-2004 Jürgen E. Fischer
4 *
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
8 * later version.
9 *
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.
14 *
15 *
16 * $Id: aha152x.c,v 2.7 2004/01/24 11:42:59 fischer Exp $
17 *
18 * $Log: aha152x.c,v $
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
26 *
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
33 *
34 * Revision 2.5 2002/04/14 11:24:53 fischer
35 * - isapnp support
36 * - abort fixed
37 * - 2.5 support
38 *
39 * Revision 2.4 2000/12/16 12:53:56 fischer
40 * - allow REQUEST SENSE to be queued
41 * - handle shared PCI interrupts
42 *
43 * Revision 2.3 2000/11/04 16:40:26 fischer
44 * - handle data overruns
45 * - extend timeout for data phases
46 *
47 * Revision 2.2 2000/08/08 19:54:53 fischer
48 * - minor changes
49 *
50 * Revision 2.1 2000/05/17 16:23:17 fischer
51 * - signature update
52 * - fix for data out w/o scatter gather
53 *
54 * Revision 2.0 1999/12/25 15:07:32 fischer
55 * - interrupt routine completly reworked
56 * - basic support for new eh code
57 *
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
63 *
64 * Revision 1.20 1999/11/07 18:37:31 fischer
65 * - synchronous operation works
66 * - resid support for sg driver
67 *
68 * Revision 1.19 1999/11/02 22:39:59 fischer
69 * - moved leading comments to README.aha152x
70 * - new additional module parameters
71 * - updates for 2.3
72 * - support for the Tripace TC1550 controller
73 * - interrupt handling changed
74 *
75 * Revision 1.18 1996/09/07 20:10:40 fischer
76 * - fixed can_queue handling (multiple outstanding commands working again)
77 *
78 * Revision 1.17 1996/08/17 16:05:14 fischer
79 * - biosparam improved
80 * - interrupt verification
81 * - updated documentation
82 * - cleanups
83 *
84 * Revision 1.16 1996/06/09 00:04:56 root
85 * - added configuration symbols for insmod (aha152x/aha152x1)
86 *
87 * Revision 1.15 1996/04/30 14:52:06 fischer
88 * - proc info fixed
89 * - support for extended translation for >1GB disks
90 *
91 * Revision 1.14 1996/01/17 15:11:20 fischer
92 * - fixed lockup in MESSAGE IN phase after reconnection
93 *
94 * Revision 1.13 1996/01/09 02:15:53 fischer
95 * - some cleanups
96 * - moved request_irq behind controller initialization
97 * (to avoid spurious interrupts)
98 *
99 * Revision 1.12 1995/12/16 12:26:07 fischer
100 * - barrier()s added
101 * - configurable RESET delay added
102 *
103 * Revision 1.11 1995/12/06 21:18:35 fischer
104 * - some minor updates
105 *
106 * Revision 1.10 1995/07/22 19:18:45 fischer
107 * - support for 2 controllers
108 * - started synchronous data transfers (not working yet)
109 *
110 * Revision 1.9 1995/03/18 09:20:24 root
111 * - patches for PCMCIA and modules
112 *
113 * Revision 1.8 1995/01/21 22:07:19 root
114 * - snarf_region => request_region
115 * - aha152x_intr interface change
116 *
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
121 *
122 * Revision 1.6 1994/11/24 20:35:27 root
123 * - problem with odd number of bytes in fifo fixed
124 *
125 * Revision 1.5 1994/10/30 14:39:56 root
126 * - abort code fixed
127 * - debugging improved
128 *
129 * Revision 1.4 1994/09/12 11:33:01 root
130 * - irqaction to request_irq
131 * - abortion updated
132 *
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
137 *
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...)
142 *
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
146 *
147 * Revision 1.0 1994/03/25 12:52:00 root
148 * - Fixed "more data than expected" problem
149 * - added new BIOS signatures
150 *
151 * Revision 0.102 1994/01/31 20:44:12 root
152 * - minor changes in insw/outsw handling
153 *
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)
157 *
158 * Revision 0.100 1993/12/10 16:58:47 root
159 * - fix for unsuccessful selections in case of non-continuous id assignments
160 * on the scsi bus.
161 *
162 * Revision 0.99 1993/10/24 16:19:59 root
163 * - fixed DATA IN (rare read errors gone)
164 *
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
168 *
169 * Revision 0.97 1993/10/09 18:53:53 root
170 * - DATA IN fixed. Rarely left data in the fifo.
171 *
172 * Revision 0.96 1993/10/03 00:53:59 root
173 * - minor changes on DATA IN
174 *
175 * Revision 0.95 1993/09/24 10:36:01 root
176 * - change handling of MSGI after reselection
177 * - fixed sti/cli
178 * - minor changes
179 *
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
184 * - reset corrected
185 * - changed message handling
186 *
187 * Revision 0.93 1993/09/15 20:41:19 root
188 * - fixed bugs with multiple outstanding commands
189 *
190 * Revision 0.92 1993/09/13 02:46:33 root
191 * - multiple outstanding commands work (no problems with IBM drive)
192 *
193 * Revision 0.91 1993/09/12 20:51:46 root
194 * added multiple outstanding commands
195 * (some problem with this $%&? IBM device remain)
196 *
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
201 *
202 * Revision 0.8 1993/09/06 23:09:39 root
203 * - added support for the drive activity light
204 * - minor changes
205 *
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
209 *
210 * Revision 0.6 1993/09/02 11:01:38 root
211 * first public release; added some signatures and biosparam()
212 *
213 * Revision 0.5 1993/08/30 10:23:30 root
214 * fixed timing problems with my IBM drive
215 *
216 * Revision 0.4 1993/08/29 14:06:52 root
217 * fixed some problems with timeouts due incomplete commands
218 *
219 * Revision 0.3 1993/08/28 15:55:03 root
220 * writing data works too. mounted and worked on a dos partition
221 *
222 * Revision 0.2 1993/08/27 22:42:07 root
223 * reading data works. Mounted a msdos partition.
224 *
225 * Revision 0.1 1993/08/25 13:38:30 root
226 * first "damn thing doesn't work" version
227 *
228 * Revision 0.0 1993/08/14 19:54:25 root
229 * empty function bodies; detect() works.
230 *
231 *
232 **************************************************************************
233
234 see Documentation/scsi/aha152x.txt for configuration details
235
236 **************************************************************************/
237
238#include <linux/module.h>
239#include <asm/irq.h>
240#include <linux/io.h>
241#include <linux/blkdev.h>
242#include <linux/completion.h>
243#include <linux/errno.h>
244#include <linux/string.h>
245#include <linux/wait.h>
246#include <linux/ioport.h>
247#include <linux/delay.h>
248#include <linux/proc_fs.h>
249#include <linux/interrupt.h>
250#include <linux/init.h>
251#include <linux/kernel.h>
252#include <linux/isapnp.h>
253#include <linux/spinlock.h>
254#include <linux/workqueue.h>
255#include <linux/list.h>
256#include <linux/slab.h>
257#include <scsi/scsicam.h>
258
259#include "scsi.h"
260#include <scsi/scsi_dbg.h>
261#include <scsi/scsi_host.h>
262#include <scsi/scsi_transport_spi.h>
263#include <scsi/scsi_eh.h>
264#include "aha152x.h"
265
266static LIST_HEAD(aha152x_host_list);
267
268
269/* DEFINES */
270
271/* For PCMCIA cards, always use AUTOCONF */
272#if defined(PCMCIA) || defined(MODULE)
273#if !defined(AUTOCONF)
274#define AUTOCONF
275#endif
276#endif
277
278#if !defined(AUTOCONF) && !defined(SETUP0)
279#error define AUTOCONF or SETUP0
280#endif
281
282#if defined(AHA152X_DEBUG)
283#define DEBUG_DEFAULT debug_eh
284
285#define DPRINTK(when,msgs...) \
286 do { if(HOSTDATA(shpnt)->debug & (when)) printk(msgs); } while(0)
287
288#define DO_LOCK(flags) \
289 do { \
290 if(spin_is_locked(&QLOCK)) { \
291 DPRINTK(debug_intr, DEBUG_LEAD "(%s:%d) already locked at %s:%d\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
292 } \
293 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locking\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
294 spin_lock_irqsave(&QLOCK,flags); \
295 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) locked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
296 QLOCKER=__func__; \
297 QLOCKERL=__LINE__; \
298 } while(0)
299
300#define DO_UNLOCK(flags) \
301 do { \
302 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocking (locked at %s:%d)\n", CMDINFO(CURRENT_SC), __func__, __LINE__, QLOCKER, QLOCKERL); \
303 spin_unlock_irqrestore(&QLOCK,flags); \
304 DPRINTK(debug_locking, DEBUG_LEAD "(%s:%d) unlocked\n", CMDINFO(CURRENT_SC), __func__, __LINE__); \
305 QLOCKER="(not locked)"; \
306 QLOCKERL=0; \
307 } while(0)
308
309#else
310#define DPRINTK(when,msgs...)
311#define DO_LOCK(flags) spin_lock_irqsave(&QLOCK,flags)
312#define DO_UNLOCK(flags) spin_unlock_irqrestore(&QLOCK,flags)
313#endif
314
315#define LEAD "(scsi%d:%d:%d) "
316#define WARN_LEAD KERN_WARNING LEAD
317#define INFO_LEAD KERN_INFO LEAD
318#define NOTE_LEAD KERN_NOTICE LEAD
319#define ERR_LEAD KERN_ERR LEAD
320#define DEBUG_LEAD KERN_DEBUG LEAD
321#define CMDINFO(cmd) \
322 (cmd) ? ((cmd)->device->host->host_no) : -1, \
323 (cmd) ? ((cmd)->device->id & 0x0f) : -1, \
324 (cmd) ? ((cmd)->device->lun & 0x07) : -1
325
326static inline void
327CMD_INC_RESID(struct scsi_cmnd *cmd, int inc)
328{
329 scsi_set_resid(cmd, scsi_get_resid(cmd) + inc);
330}
331
332#define DELAY_DEFAULT 1000
333
334#if defined(PCMCIA)
335#define IRQ_MIN 0
336#define IRQ_MAX 16
337#else
338#define IRQ_MIN 9
339#if defined(__PPC)
340#define IRQ_MAX (nr_irqs-1)
341#else
342#define IRQ_MAX 12
343#endif
344#endif
345
346enum {
347 not_issued = 0x0001, /* command not yet issued */
348 selecting = 0x0002, /* target is beeing selected */
349 identified = 0x0004, /* IDENTIFY was sent */
350 disconnected = 0x0008, /* target disconnected */
351 completed = 0x0010, /* target sent COMMAND COMPLETE */
352 aborted = 0x0020, /* ABORT was sent */
353 resetted = 0x0040, /* BUS DEVICE RESET was sent */
354 spiordy = 0x0080, /* waiting for SPIORDY to raise */
355 syncneg = 0x0100, /* synchronous negotiation in progress */
356 aborting = 0x0200, /* ABORT is pending */
357 resetting = 0x0400, /* BUS DEVICE RESET is pending */
358 check_condition = 0x0800, /* requesting sense after CHECK CONDITION */
359};
360
361MODULE_AUTHOR("Jürgen Fischer");
362MODULE_DESCRIPTION(AHA152X_REVID);
363MODULE_LICENSE("GPL");
364
365#if !defined(PCMCIA)
366#if defined(MODULE)
367static int io[] = {0, 0};
368module_param_array(io, int, NULL, 0);
369MODULE_PARM_DESC(io,"base io address of controller");
370
371static int irq[] = {0, 0};
372module_param_array(irq, int, NULL, 0);
373MODULE_PARM_DESC(irq,"interrupt for controller");
374
375static int scsiid[] = {7, 7};
376module_param_array(scsiid, int, NULL, 0);
377MODULE_PARM_DESC(scsiid,"scsi id of controller");
378
379static int reconnect[] = {1, 1};
380module_param_array(reconnect, int, NULL, 0);
381MODULE_PARM_DESC(reconnect,"allow targets to disconnect");
382
383static int parity[] = {1, 1};
384module_param_array(parity, int, NULL, 0);
385MODULE_PARM_DESC(parity,"use scsi parity");
386
387static int sync[] = {1, 1};
388module_param_array(sync, int, NULL, 0);
389MODULE_PARM_DESC(sync,"use synchronous transfers");
390
391static int delay[] = {DELAY_DEFAULT, DELAY_DEFAULT};
392module_param_array(delay, int, NULL, 0);
393MODULE_PARM_DESC(delay,"scsi reset delay");
394
395static int exttrans[] = {0, 0};
396module_param_array(exttrans, int, NULL, 0);
397MODULE_PARM_DESC(exttrans,"use extended translation");
398
399#if !defined(AHA152X_DEBUG)
400static int aha152x[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
401module_param_array(aha152x, int, NULL, 0);
402MODULE_PARM_DESC(aha152x, "parameters for first controller");
403
404static int aha152x1[] = {0, 11, 7, 1, 1, 0, DELAY_DEFAULT, 0};
405module_param_array(aha152x1, int, NULL, 0);
406MODULE_PARM_DESC(aha152x1, "parameters for second controller");
407#else
408static int debug[] = {DEBUG_DEFAULT, DEBUG_DEFAULT};
409module_param_array(debug, int, NULL, 0);
410MODULE_PARM_DESC(debug, "flags for driver debugging");
411
412static int aha152x[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
413module_param_array(aha152x, int, NULL, 0);
414MODULE_PARM_DESC(aha152x, "parameters for first controller");
415
416static int aha152x1[] = {0, 11, 7, 1, 1, 1, DELAY_DEFAULT, 0, DEBUG_DEFAULT};
417module_param_array(aha152x1, int, NULL, 0);
418MODULE_PARM_DESC(aha152x1, "parameters for second controller");
419#endif /* !defined(AHA152X_DEBUG) */
420#endif /* MODULE */
421
422#ifdef __ISAPNP__
423static struct isapnp_device_id id_table[] = {
424 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1502), 0 },
425 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1505), 0 },
426 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1510), 0 },
427 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1515), 0 },
428 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1520), 0 },
429 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2015), 0 },
430 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1522), 0 },
431 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x2215), 0 },
432 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1530), 0 },
433 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3015), 0 },
434 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x1532), 0 },
435 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x3215), 0 },
436 { ISAPNP_ANY_ID, ISAPNP_ANY_ID, ISAPNP_VENDOR('A', 'D', 'P'), ISAPNP_FUNCTION(0x6360), 0 },
437 { ISAPNP_DEVICE_SINGLE_END, }
438};
439MODULE_DEVICE_TABLE(isapnp, id_table);
440#endif /* ISAPNP */
441
442#endif /* !PCMCIA */
443
444static struct scsi_host_template aha152x_driver_template;
445
446/*
447 * internal states of the host
448 *
449 */
450enum aha152x_state {
451 idle=0,
452 unknown,
453 seldo,
454 seldi,
455 selto,
456 busfree,
457 msgo,
458 cmd,
459 msgi,
460 status,
461 datai,
462 datao,
463 parerr,
464 rsti,
465 maxstate
466};
467
468/*
469 * current state information of the host
470 *
471 */
472struct aha152x_hostdata {
473 Scsi_Cmnd *issue_SC;
474 /* pending commands to issue */
475
476 Scsi_Cmnd *current_SC;
477 /* current command on the bus */
478
479 Scsi_Cmnd *disconnected_SC;
480 /* commands that disconnected */
481
482 Scsi_Cmnd *done_SC;
483 /* command that was completed */
484
485 spinlock_t lock;
486 /* host lock */
487
488#if defined(AHA152X_DEBUG)
489 const char *locker;
490 /* which function has the lock */
491 int lockerl; /* where did it get it */
492
493 int debug; /* current debugging setting */
494#endif
495
496#if defined(AHA152X_STAT)
497 int total_commands;
498 int disconnections;
499 int busfree_without_any_action;
500 int busfree_without_old_command;
501 int busfree_without_new_command;
502 int busfree_without_done_command;
503 int busfree_with_check_condition;
504 int count[maxstate];
505 int count_trans[maxstate];
506 unsigned long time[maxstate];
507#endif
508
509 int commands; /* current number of commands */
510
511 int reconnect; /* disconnection allowed */
512 int parity; /* parity checking enabled */
513 int synchronous; /* synchronous transferes enabled */
514 int delay; /* reset out delay */
515 int ext_trans; /* extended translation enabled */
516
517 int swint; /* software-interrupt was fired during detect() */
518 int service; /* bh needs to be run */
519 int in_intr; /* bh is running */
520
521 /* current state,
522 previous state,
523 last state different from current state */
524 enum aha152x_state state, prevstate, laststate;
525
526 int target;
527 /* reconnecting target */
528
529 unsigned char syncrate[8];
530 /* current synchronous transfer agreements */
531
532 unsigned char syncneg[8];
533 /* 0: no negotiation;
534 * 1: negotiation in progress;
535 * 2: negotiation completed
536 */
537
538 int cmd_i;
539 /* number of sent bytes of current command */
540
541 int msgi_len;
542 /* number of received message bytes */
543 unsigned char msgi[256];
544 /* received message bytes */
545
546 int msgo_i, msgo_len;
547 /* number of sent bytes and length of current messages */
548 unsigned char msgo[256];
549 /* pending messages */
550
551 int data_len;
552 /* number of sent/received bytes in dataphase */
553
554 unsigned long io_port0;
555 unsigned long io_port1;
556
557#ifdef __ISAPNP__
558 struct pnp_dev *pnpdev;
559#endif
560 struct list_head host_list;
561};
562
563
564/*
565 * host specific command extension
566 *
567 */
568struct aha152x_scdata {
569 Scsi_Cmnd *next; /* next sc in queue */
570 struct completion *done;/* semaphore to block on */
571 struct scsi_eh_save ses;
572};
573
574/* access macros for hostdata */
575
576#define HOSTDATA(shpnt) ((struct aha152x_hostdata *) &shpnt->hostdata)
577
578#define HOSTNO ((shpnt)->host_no)
579
580#define CURRENT_SC (HOSTDATA(shpnt)->current_SC)
581#define DONE_SC (HOSTDATA(shpnt)->done_SC)
582#define ISSUE_SC (HOSTDATA(shpnt)->issue_SC)
583#define DISCONNECTED_SC (HOSTDATA(shpnt)->disconnected_SC)
584#define QLOCK (HOSTDATA(shpnt)->lock)
585#define QLOCKER (HOSTDATA(shpnt)->locker)
586#define QLOCKERL (HOSTDATA(shpnt)->lockerl)
587
588#define STATE (HOSTDATA(shpnt)->state)
589#define PREVSTATE (HOSTDATA(shpnt)->prevstate)
590#define LASTSTATE (HOSTDATA(shpnt)->laststate)
591
592#define RECONN_TARGET (HOSTDATA(shpnt)->target)
593
594#define CMD_I (HOSTDATA(shpnt)->cmd_i)
595
596#define MSGO(i) (HOSTDATA(shpnt)->msgo[i])
597#define MSGO_I (HOSTDATA(shpnt)->msgo_i)
598#define MSGOLEN (HOSTDATA(shpnt)->msgo_len)
599#define ADDMSGO(x) (MSGOLEN<256 ? (void)(MSGO(MSGOLEN++)=x) : aha152x_error(shpnt,"MSGO overflow"))
600
601#define MSGI(i) (HOSTDATA(shpnt)->msgi[i])
602#define MSGILEN (HOSTDATA(shpnt)->msgi_len)
603#define ADDMSGI(x) (MSGILEN<256 ? (void)(MSGI(MSGILEN++)=x) : aha152x_error(shpnt,"MSGI overflow"))
604
605#define DATA_LEN (HOSTDATA(shpnt)->data_len)
606
607#define SYNCRATE (HOSTDATA(shpnt)->syncrate[CURRENT_SC->device->id])
608#define SYNCNEG (HOSTDATA(shpnt)->syncneg[CURRENT_SC->device->id])
609
610#define DELAY (HOSTDATA(shpnt)->delay)
611#define EXT_TRANS (HOSTDATA(shpnt)->ext_trans)
612#define TC1550 (HOSTDATA(shpnt)->tc1550)
613#define RECONNECT (HOSTDATA(shpnt)->reconnect)
614#define PARITY (HOSTDATA(shpnt)->parity)
615#define SYNCHRONOUS (HOSTDATA(shpnt)->synchronous)
616
617#define HOSTIOPORT0 (HOSTDATA(shpnt)->io_port0)
618#define HOSTIOPORT1 (HOSTDATA(shpnt)->io_port1)
619
620#define SCDATA(SCpnt) ((struct aha152x_scdata *) (SCpnt)->host_scribble)
621#define SCNEXT(SCpnt) SCDATA(SCpnt)->next
622#define SCSEM(SCpnt) SCDATA(SCpnt)->done
623
624#define SG_ADDRESS(buffer) ((char *) sg_virt((buffer)))
625
626/* state handling */
627static void seldi_run(struct Scsi_Host *shpnt);
628static void seldo_run(struct Scsi_Host *shpnt);
629static void selto_run(struct Scsi_Host *shpnt);
630static void busfree_run(struct Scsi_Host *shpnt);
631
632static void msgo_init(struct Scsi_Host *shpnt);
633static void msgo_run(struct Scsi_Host *shpnt);
634static void msgo_end(struct Scsi_Host *shpnt);
635
636static void cmd_init(struct Scsi_Host *shpnt);
637static void cmd_run(struct Scsi_Host *shpnt);
638static void cmd_end(struct Scsi_Host *shpnt);
639
640static void datai_init(struct Scsi_Host *shpnt);
641static void datai_run(struct Scsi_Host *shpnt);
642static void datai_end(struct Scsi_Host *shpnt);
643
644static void datao_init(struct Scsi_Host *shpnt);
645static void datao_run(struct Scsi_Host *shpnt);
646static void datao_end(struct Scsi_Host *shpnt);
647
648static void status_run(struct Scsi_Host *shpnt);
649
650static void msgi_run(struct Scsi_Host *shpnt);
651static void msgi_end(struct Scsi_Host *shpnt);
652
653static void parerr_run(struct Scsi_Host *shpnt);
654static void rsti_run(struct Scsi_Host *shpnt);
655
656static void is_complete(struct Scsi_Host *shpnt);
657
658/*
659 * driver states
660 *
661 */
662static struct {
663 char *name;
664 void (*init)(struct Scsi_Host *);
665 void (*run)(struct Scsi_Host *);
666 void (*end)(struct Scsi_Host *);
667 int spio;
668} states[] = {
669 { "idle", NULL, NULL, NULL, 0},
670 { "unknown", NULL, NULL, NULL, 0},
671 { "seldo", NULL, seldo_run, NULL, 0},
672 { "seldi", NULL, seldi_run, NULL, 0},
673 { "selto", NULL, selto_run, NULL, 0},
674 { "busfree", NULL, busfree_run, NULL, 0},
675 { "msgo", msgo_init, msgo_run, msgo_end, 1},
676 { "cmd", cmd_init, cmd_run, cmd_end, 1},
677 { "msgi", NULL, msgi_run, msgi_end, 1},
678 { "status", NULL, status_run, NULL, 1},
679 { "datai", datai_init, datai_run, datai_end, 0},
680 { "datao", datao_init, datao_run, datao_end, 0},
681 { "parerr", NULL, parerr_run, NULL, 0},
682 { "rsti", NULL, rsti_run, NULL, 0},
683};
684
685/* setup & interrupt */
686static irqreturn_t intr(int irq, void *dev_id);
687static void reset_ports(struct Scsi_Host *shpnt);
688static void aha152x_error(struct Scsi_Host *shpnt, char *msg);
689static void done(struct Scsi_Host *shpnt, int error);
690
691/* diagnostics */
692static void disp_ports(struct Scsi_Host *shpnt);
693static void show_command(Scsi_Cmnd * ptr);
694static void show_queues(struct Scsi_Host *shpnt);
695static void disp_enintr(struct Scsi_Host *shpnt);
696
697
698/*
699 * queue services:
700 *
701 */
702static inline void append_SC(Scsi_Cmnd **SC, Scsi_Cmnd *new_SC)
703{
704 Scsi_Cmnd *end;
705
706 SCNEXT(new_SC) = NULL;
707 if (!*SC)
708 *SC = new_SC;
709 else {
710 for (end = *SC; SCNEXT(end); end = SCNEXT(end))
711 ;
712 SCNEXT(end) = new_SC;
713 }
714}
715
716static inline Scsi_Cmnd *remove_first_SC(Scsi_Cmnd ** SC)
717{
718 Scsi_Cmnd *ptr;
719
720 ptr = *SC;
721 if (ptr) {
722 *SC = SCNEXT(*SC);
723 SCNEXT(ptr)=NULL;
724 }
725 return ptr;
726}
727
728static inline Scsi_Cmnd *remove_lun_SC(Scsi_Cmnd ** SC, int target, int lun)
729{
730 Scsi_Cmnd *ptr, *prev;
731
732 for (ptr = *SC, prev = NULL;
733 ptr && ((ptr->device->id != target) || (ptr->device->lun != lun));
734 prev = ptr, ptr = SCNEXT(ptr))
735 ;
736
737 if (ptr) {
738 if (prev)
739 SCNEXT(prev) = SCNEXT(ptr);
740 else
741 *SC = SCNEXT(ptr);
742
743 SCNEXT(ptr)=NULL;
744 }
745
746 return ptr;
747}
748
749static inline Scsi_Cmnd *remove_SC(Scsi_Cmnd **SC, Scsi_Cmnd *SCp)
750{
751 Scsi_Cmnd *ptr, *prev;
752
753 for (ptr = *SC, prev = NULL;
754 ptr && SCp!=ptr;
755 prev = ptr, ptr = SCNEXT(ptr))
756 ;
757
758 if (ptr) {
759 if (prev)
760 SCNEXT(prev) = SCNEXT(ptr);
761 else
762 *SC = SCNEXT(ptr);
763
764 SCNEXT(ptr)=NULL;
765 }
766
767 return ptr;
768}
769
770static irqreturn_t swintr(int irqno, void *dev_id)
771{
772 struct Scsi_Host *shpnt = dev_id;
773
774 HOSTDATA(shpnt)->swint++;
775
776 SETPORT(DMACNTRL0, INTEN);
777 return IRQ_HANDLED;
778}
779
780struct Scsi_Host *aha152x_probe_one(struct aha152x_setup *setup)
781{
782 struct Scsi_Host *shpnt;
783
784 shpnt = scsi_host_alloc(&aha152x_driver_template, sizeof(struct aha152x_hostdata));
785 if (!shpnt) {
786 printk(KERN_ERR "aha152x: scsi_host_alloc failed\n");
787 return NULL;
788 }
789
790 memset(HOSTDATA(shpnt), 0, sizeof *HOSTDATA(shpnt));
791 INIT_LIST_HEAD(&HOSTDATA(shpnt)->host_list);
792
793 /* need to have host registered before triggering any interrupt */
794 list_add_tail(&HOSTDATA(shpnt)->host_list, &aha152x_host_list);
795
796 shpnt->io_port = setup->io_port;
797 shpnt->n_io_port = IO_RANGE;
798 shpnt->irq = setup->irq;
799
800 if (!setup->tc1550) {
801 HOSTIOPORT0 = setup->io_port;
802 HOSTIOPORT1 = setup->io_port;
803 } else {
804 HOSTIOPORT0 = setup->io_port+0x10;
805 HOSTIOPORT1 = setup->io_port-0x10;
806 }
807
808 spin_lock_init(&QLOCK);
809 RECONNECT = setup->reconnect;
810 SYNCHRONOUS = setup->synchronous;
811 PARITY = setup->parity;
812 DELAY = setup->delay;
813 EXT_TRANS = setup->ext_trans;
814
815#if defined(AHA152X_DEBUG)
816 HOSTDATA(shpnt)->debug = setup->debug;
817#endif
818
819 SETPORT(SCSIID, setup->scsiid << 4);
820 shpnt->this_id = setup->scsiid;
821
822 if (setup->reconnect)
823 shpnt->can_queue = AHA152X_MAXQUEUE;
824
825 /* RESET OUT */
826 printk("aha152x: resetting bus...\n");
827 SETPORT(SCSISEQ, SCSIRSTO);
828 mdelay(256);
829 SETPORT(SCSISEQ, 0);
830 mdelay(DELAY);
831
832 reset_ports(shpnt);
833
834 printk(KERN_INFO
835 "aha152x%d%s: "
836 "vital data: rev=%x, "
837 "io=0x%03lx (0x%03lx/0x%03lx), "
838 "irq=%d, "
839 "scsiid=%d, "
840 "reconnect=%s, "
841 "parity=%s, "
842 "synchronous=%s, "
843 "delay=%d, "
844 "extended translation=%s\n",
845 shpnt->host_no, setup->tc1550 ? " (tc1550 mode)" : "",
846 GETPORT(REV) & 0x7,
847 shpnt->io_port, HOSTIOPORT0, HOSTIOPORT1,
848 shpnt->irq,
849 shpnt->this_id,
850 RECONNECT ? "enabled" : "disabled",
851 PARITY ? "enabled" : "disabled",
852 SYNCHRONOUS ? "enabled" : "disabled",
853 DELAY,
854 EXT_TRANS ? "enabled" : "disabled");
855
856 /* not expecting any interrupts */
857 SETPORT(SIMODE0, 0);
858 SETPORT(SIMODE1, 0);
859
860 if (request_irq(shpnt->irq, swintr, IRQF_SHARED, "aha152x", shpnt)) {
861 printk(KERN_ERR "aha152x%d: irq %d busy.\n", shpnt->host_no, shpnt->irq);
862 goto out_host_put;
863 }
864
865 HOSTDATA(shpnt)->swint = 0;
866
867 printk(KERN_INFO "aha152x%d: trying software interrupt, ", shpnt->host_no);
868
869 mb();
870 SETPORT(DMACNTRL0, SWINT|INTEN);
871 mdelay(1000);
872 free_irq(shpnt->irq, shpnt);
873
874 if (!HOSTDATA(shpnt)->swint) {
875 if (TESTHI(DMASTAT, INTSTAT)) {
876 printk("lost.\n");
877 } else {
878 printk("failed.\n");
879 }
880
881 SETPORT(DMACNTRL0, INTEN);
882
883 printk(KERN_ERR "aha152x%d: irq %d possibly wrong. "
884 "Please verify.\n", shpnt->host_no, shpnt->irq);
885 goto out_host_put;
886 }
887 printk("ok.\n");
888
889
890 /* clear interrupts */
891 SETPORT(SSTAT0, 0x7f);
892 SETPORT(SSTAT1, 0xef);
893
894 if (request_irq(shpnt->irq, intr, IRQF_SHARED, "aha152x", shpnt)) {
895 printk(KERN_ERR "aha152x%d: failed to reassign irq %d.\n", shpnt->host_no, shpnt->irq);
896 goto out_host_put;
897 }
898
899 if( scsi_add_host(shpnt, NULL) ) {
900 free_irq(shpnt->irq, shpnt);
901 printk(KERN_ERR "aha152x%d: failed to add host.\n", shpnt->host_no);
902 goto out_host_put;
903 }
904
905 scsi_scan_host(shpnt);
906
907 return shpnt;
908
909out_host_put:
910 list_del(&HOSTDATA(shpnt)->host_list);
911 scsi_host_put(shpnt);
912
913 return NULL;
914}
915
916void aha152x_release(struct Scsi_Host *shpnt)
917{
918 if (!shpnt)
919 return;
920
921 scsi_remove_host(shpnt);
922 if (shpnt->irq)
923 free_irq(shpnt->irq, shpnt);
924
925#if !defined(PCMCIA)
926 if (shpnt->io_port)
927 release_region(shpnt->io_port, IO_RANGE);
928#endif
929
930#ifdef __ISAPNP__
931 if (HOSTDATA(shpnt)->pnpdev)
932 pnp_device_detach(HOSTDATA(shpnt)->pnpdev);
933#endif
934
935 list_del(&HOSTDATA(shpnt)->host_list);
936 scsi_host_put(shpnt);
937}
938
939
940/*
941 * setup controller to generate interrupts depending
942 * on current state (lock has to be acquired)
943 *
944 */
945static int setup_expected_interrupts(struct Scsi_Host *shpnt)
946{
947 if(CURRENT_SC) {
948 CURRENT_SC->SCp.phase |= 1 << 16;
949
950 if(CURRENT_SC->SCp.phase & selecting) {
951 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (seldo) (seltimo) (seldi)\n", CMDINFO(CURRENT_SC));
952 SETPORT(SSTAT1, SELTO);
953 SETPORT(SIMODE0, ENSELDO | (DISCONNECTED_SC ? ENSELDI : 0));
954 SETPORT(SIMODE1, ENSELTIMO);
955 } else {
956 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (busfree) %s\n", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.phase & spiordy ? "(spiordy)" : "");
957 SETPORT(SIMODE0, (CURRENT_SC->SCp.phase & spiordy) ? ENSPIORDY : 0);
958 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
959 }
960 } else if(STATE==seldi) {
961 DPRINTK(debug_intr, DEBUG_LEAD "expecting: (phase change) (identify)\n", CMDINFO(CURRENT_SC));
962 SETPORT(SIMODE0, 0);
963 SETPORT(SIMODE1, ENPHASEMIS | ENSCSIRST | ENSCSIPERR | ENBUSFREE);
964 } else {
965 DPRINTK(debug_intr, DEBUG_LEAD "expecting: %s %s\n",
966 CMDINFO(CURRENT_SC),
967 DISCONNECTED_SC ? "(reselection)" : "",
968 ISSUE_SC ? "(busfree)" : "");
969 SETPORT(SIMODE0, DISCONNECTED_SC ? ENSELDI : 0);
970 SETPORT(SIMODE1, ENSCSIRST | ( (ISSUE_SC||DONE_SC) ? ENBUSFREE : 0));
971 }
972
973 if(!HOSTDATA(shpnt)->in_intr)
974 SETBITS(DMACNTRL0, INTEN);
975
976 return TESTHI(DMASTAT, INTSTAT);
977}
978
979
980/*
981 * Queue a command and setup interrupts for a free bus.
982 */
983static int aha152x_internal_queue(Scsi_Cmnd *SCpnt, struct completion *complete,
984 int phase, void (*done)(Scsi_Cmnd *))
985{
986 struct Scsi_Host *shpnt = SCpnt->device->host;
987 unsigned long flags;
988
989#if defined(AHA152X_DEBUG)
990 if (HOSTDATA(shpnt)->debug & debug_queue) {
991 printk(INFO_LEAD "queue: %p; cmd_len=%d pieces=%d size=%u cmnd=",
992 CMDINFO(SCpnt), SCpnt, SCpnt->cmd_len,
993 scsi_sg_count(SCpnt), scsi_bufflen(SCpnt));
994 __scsi_print_command(SCpnt->cmnd);
995 }
996#endif
997
998 SCpnt->scsi_done = done;
999 SCpnt->SCp.phase = not_issued | phase;
1000 SCpnt->SCp.Status = 0x1; /* Ilegal status by SCSI standard */
1001 SCpnt->SCp.Message = 0;
1002 SCpnt->SCp.have_data_in = 0;
1003 SCpnt->SCp.sent_command = 0;
1004
1005 if(SCpnt->SCp.phase & (resetting|check_condition)) {
1006 if (!SCpnt->host_scribble || SCSEM(SCpnt) || SCNEXT(SCpnt)) {
1007 printk(ERR_LEAD "cannot reuse command\n", CMDINFO(SCpnt));
1008 return FAILED;
1009 }
1010 } else {
1011 SCpnt->host_scribble = kmalloc(sizeof(struct aha152x_scdata), GFP_ATOMIC);
1012 if(!SCpnt->host_scribble) {
1013 printk(ERR_LEAD "allocation failed\n", CMDINFO(SCpnt));
1014 return FAILED;
1015 }
1016 }
1017
1018 SCNEXT(SCpnt) = NULL;
1019 SCSEM(SCpnt) = complete;
1020
1021 /* setup scratch area
1022 SCp.ptr : buffer pointer
1023 SCp.this_residual : buffer length
1024 SCp.buffer : next buffer
1025 SCp.buffers_residual : left buffers in list
1026 SCp.phase : current state of the command */
1027
1028 if ((phase & resetting) || !scsi_sglist(SCpnt)) {
1029 SCpnt->SCp.ptr = NULL;
1030 SCpnt->SCp.this_residual = 0;
1031 scsi_set_resid(SCpnt, 0);
1032 SCpnt->SCp.buffer = NULL;
1033 SCpnt->SCp.buffers_residual = 0;
1034 } else {
1035 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1036 SCpnt->SCp.buffer = scsi_sglist(SCpnt);
1037 SCpnt->SCp.ptr = SG_ADDRESS(SCpnt->SCp.buffer);
1038 SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length;
1039 SCpnt->SCp.buffers_residual = scsi_sg_count(SCpnt) - 1;
1040 }
1041
1042 DO_LOCK(flags);
1043
1044#if defined(AHA152X_STAT)
1045 HOSTDATA(shpnt)->total_commands++;
1046#endif
1047
1048 /* Turn led on, when this is the first command. */
1049 HOSTDATA(shpnt)->commands++;
1050 if (HOSTDATA(shpnt)->commands==1)
1051 SETPORT(PORTA, 1);
1052
1053 append_SC(&ISSUE_SC, SCpnt);
1054
1055 if(!HOSTDATA(shpnt)->in_intr)
1056 setup_expected_interrupts(shpnt);
1057
1058 DO_UNLOCK(flags);
1059
1060 return 0;
1061}
1062
1063/*
1064 * queue a command
1065 *
1066 */
1067static int aha152x_queue_lck(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
1068{
1069#if 0
1070 if(*SCpnt->cmnd == REQUEST_SENSE) {
1071 SCpnt->result = 0;
1072 done(SCpnt);
1073
1074 return 0;
1075 }
1076#endif
1077
1078 return aha152x_internal_queue(SCpnt, NULL, 0, done);
1079}
1080
1081static DEF_SCSI_QCMD(aha152x_queue)
1082
1083
1084/*
1085 *
1086 *
1087 */
1088static void reset_done(Scsi_Cmnd *SCpnt)
1089{
1090#if 0
1091 struct Scsi_Host *shpnt = SCpnt->host;
1092 DPRINTK(debug_eh, INFO_LEAD "reset_done called\n", CMDINFO(SCpnt));
1093#endif
1094 if(SCSEM(SCpnt)) {
1095 complete(SCSEM(SCpnt));
1096 } else {
1097 printk(KERN_ERR "aha152x: reset_done w/o completion\n");
1098 }
1099}
1100
1101/*
1102 * Abort a command
1103 *
1104 */
1105static int aha152x_abort(Scsi_Cmnd *SCpnt)
1106{
1107 struct Scsi_Host *shpnt = SCpnt->device->host;
1108 Scsi_Cmnd *ptr;
1109 unsigned long flags;
1110
1111#if defined(AHA152X_DEBUG)
1112 if(HOSTDATA(shpnt)->debug & debug_eh) {
1113 printk(DEBUG_LEAD "abort(%p)", CMDINFO(SCpnt), SCpnt);
1114 show_queues(shpnt);
1115 }
1116#endif
1117
1118 DO_LOCK(flags);
1119
1120 ptr=remove_SC(&ISSUE_SC, SCpnt);
1121
1122 if(ptr) {
1123 DPRINTK(debug_eh, DEBUG_LEAD "not yet issued - SUCCESS\n", CMDINFO(SCpnt));
1124
1125 HOSTDATA(shpnt)->commands--;
1126 if (!HOSTDATA(shpnt)->commands)
1127 SETPORT(PORTA, 0);
1128 DO_UNLOCK(flags);
1129
1130 kfree(SCpnt->host_scribble);
1131 SCpnt->host_scribble=NULL;
1132
1133 return SUCCESS;
1134 }
1135
1136 DO_UNLOCK(flags);
1137
1138 /*
1139 * FIXME:
1140 * for current command: queue ABORT for message out and raise ATN
1141 * for disconnected command: pseudo SC with ABORT message or ABORT on reselection?
1142 *
1143 */
1144
1145 printk(ERR_LEAD "cannot abort running or disconnected command\n", CMDINFO(SCpnt));
1146
1147 return FAILED;
1148}
1149
1150/*
1151 * Reset a device
1152 *
1153 */
1154static int aha152x_device_reset(Scsi_Cmnd * SCpnt)
1155{
1156 struct Scsi_Host *shpnt = SCpnt->device->host;
1157 DECLARE_COMPLETION(done);
1158 int ret, issued, disconnected;
1159 unsigned char old_cmd_len = SCpnt->cmd_len;
1160 unsigned long flags;
1161 unsigned long timeleft;
1162
1163#if defined(AHA152X_DEBUG)
1164 if(HOSTDATA(shpnt)->debug & debug_eh) {
1165 printk(INFO_LEAD "aha152x_device_reset(%p)", CMDINFO(SCpnt), SCpnt);
1166 show_queues(shpnt);
1167 }
1168#endif
1169
1170 if(CURRENT_SC==SCpnt) {
1171 printk(ERR_LEAD "cannot reset current device\n", CMDINFO(SCpnt));
1172 return FAILED;
1173 }
1174
1175 DO_LOCK(flags);
1176 issued = remove_SC(&ISSUE_SC, SCpnt) == NULL;
1177 disconnected = issued && remove_SC(&DISCONNECTED_SC, SCpnt);
1178 DO_UNLOCK(flags);
1179
1180 SCpnt->cmd_len = 0;
1181
1182 aha152x_internal_queue(SCpnt, &done, resetting, reset_done);
1183
1184 timeleft = wait_for_completion_timeout(&done, 100*HZ);
1185 if (!timeleft) {
1186 /* remove command from issue queue */
1187 DO_LOCK(flags);
1188 remove_SC(&ISSUE_SC, SCpnt);
1189 DO_UNLOCK(flags);
1190 }
1191
1192 SCpnt->cmd_len = old_cmd_len;
1193
1194 DO_LOCK(flags);
1195
1196 if(SCpnt->SCp.phase & resetted) {
1197 HOSTDATA(shpnt)->commands--;
1198 if (!HOSTDATA(shpnt)->commands)
1199 SETPORT(PORTA, 0);
1200 kfree(SCpnt->host_scribble);
1201 SCpnt->host_scribble=NULL;
1202
1203 ret = SUCCESS;
1204 } else {
1205 /* requeue */
1206 if(!issued) {
1207 append_SC(&ISSUE_SC, SCpnt);
1208 } else if(disconnected) {
1209 append_SC(&DISCONNECTED_SC, SCpnt);
1210 }
1211
1212 ret = FAILED;
1213 }
1214
1215 DO_UNLOCK(flags);
1216 return ret;
1217}
1218
1219static void free_hard_reset_SCs(struct Scsi_Host *shpnt, Scsi_Cmnd **SCs)
1220{
1221 Scsi_Cmnd *ptr;
1222
1223 ptr=*SCs;
1224 while(ptr) {
1225 Scsi_Cmnd *next;
1226
1227 if(SCDATA(ptr)) {
1228 next = SCNEXT(ptr);
1229 } else {
1230 printk(DEBUG_LEAD "queue corrupted at %p\n", CMDINFO(ptr), ptr);
1231 next = NULL;
1232 }
1233
1234 if (!ptr->device->soft_reset) {
1235 DPRINTK(debug_eh, DEBUG_LEAD "disconnected command %p removed\n", CMDINFO(ptr), ptr);
1236 remove_SC(SCs, ptr);
1237 HOSTDATA(shpnt)->commands--;
1238 kfree(ptr->host_scribble);
1239 ptr->host_scribble=NULL;
1240 }
1241
1242 ptr = next;
1243 }
1244}
1245
1246/*
1247 * Reset the bus
1248 *
1249 */
1250static int aha152x_bus_reset_host(struct Scsi_Host *shpnt)
1251{
1252 unsigned long flags;
1253
1254 DO_LOCK(flags);
1255
1256#if defined(AHA152X_DEBUG)
1257 if(HOSTDATA(shpnt)->debug & debug_eh) {
1258 printk(KERN_DEBUG "scsi%d: bus reset", shpnt->host_no);
1259 show_queues(shpnt);
1260 }
1261#endif
1262
1263 free_hard_reset_SCs(shpnt, &ISSUE_SC);
1264 free_hard_reset_SCs(shpnt, &DISCONNECTED_SC);
1265
1266 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting bus\n", shpnt->host_no);
1267
1268 SETPORT(SCSISEQ, SCSIRSTO);
1269 mdelay(256);
1270 SETPORT(SCSISEQ, 0);
1271 mdelay(DELAY);
1272
1273 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: bus resetted\n", shpnt->host_no);
1274
1275 setup_expected_interrupts(shpnt);
1276 if(HOSTDATA(shpnt)->commands==0)
1277 SETPORT(PORTA, 0);
1278
1279 DO_UNLOCK(flags);
1280
1281 return SUCCESS;
1282}
1283
1284/*
1285 * Reset the bus
1286 *
1287 */
1288static int aha152x_bus_reset(Scsi_Cmnd *SCpnt)
1289{
1290 return aha152x_bus_reset_host(SCpnt->device->host);
1291}
1292
1293/*
1294 * Restore default values to the AIC-6260 registers and reset the fifos
1295 *
1296 */
1297static void reset_ports(struct Scsi_Host *shpnt)
1298{
1299 unsigned long flags;
1300
1301 /* disable interrupts */
1302 SETPORT(DMACNTRL0, RSTFIFO);
1303
1304 SETPORT(SCSISEQ, 0);
1305
1306 SETPORT(SXFRCTL1, 0);
1307 SETPORT(SCSISIG, 0);
1308 SETRATE(0);
1309
1310 /* clear all interrupt conditions */
1311 SETPORT(SSTAT0, 0x7f);
1312 SETPORT(SSTAT1, 0xef);
1313
1314 SETPORT(SSTAT4, SYNCERR | FWERR | FRERR);
1315
1316 SETPORT(DMACNTRL0, 0);
1317 SETPORT(DMACNTRL1, 0);
1318
1319 SETPORT(BRSTCNTRL, 0xf1);
1320
1321 /* clear SCSI fifos and transfer count */
1322 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1323 SETPORT(SXFRCTL0, CH1);
1324
1325 DO_LOCK(flags);
1326 setup_expected_interrupts(shpnt);
1327 DO_UNLOCK(flags);
1328}
1329
1330/*
1331 * Reset the host (bus and controller)
1332 *
1333 */
1334int aha152x_host_reset_host(struct Scsi_Host *shpnt)
1335{
1336 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: host reset\n", shpnt->host_no);
1337
1338 aha152x_bus_reset_host(shpnt);
1339
1340 DPRINTK(debug_eh, KERN_DEBUG "scsi%d: resetting ports\n", shpnt->host_no);
1341 reset_ports(shpnt);
1342
1343 return SUCCESS;
1344}
1345
1346/*
1347 * Reset the host (bus and controller)
1348 *
1349 */
1350static int aha152x_host_reset(Scsi_Cmnd *SCpnt)
1351{
1352 return aha152x_host_reset_host(SCpnt->device->host);
1353}
1354
1355/*
1356 * Return the "logical geometry"
1357 *
1358 */
1359static int aha152x_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1360 sector_t capacity, int *info_array)
1361{
1362 struct Scsi_Host *shpnt = sdev->host;
1363
1364 /* try default translation */
1365 info_array[0] = 64;
1366 info_array[1] = 32;
1367 info_array[2] = (unsigned long)capacity / (64 * 32);
1368
1369 /* for disks >1GB do some guessing */
1370 if (info_array[2] >= 1024) {
1371 int info[3];
1372
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))) {
1376 if (EXT_TRANS) {
1377 printk(KERN_NOTICE
1378 "aha152x: unable to verify geometry for disk with >1GB.\n"
1379 " using extended translation.\n");
1380 info_array[0] = 255;
1381 info_array[1] = 63;
1382 info_array[2] = (unsigned long)capacity / (255 * 63);
1383 } else {
1384 printk(KERN_NOTICE
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");
1389 }
1390 } else {
1391 info_array[0] = info[0];
1392 info_array[1] = info[1];
1393 info_array[2] = info[2];
1394
1395 if (info[0] == 255 && !EXT_TRANS) {
1396 printk(KERN_NOTICE
1397 "aha152x: current partition table is using extended translation.\n"
1398 " using it also, although it's not explicitly enabled.\n");
1399 }
1400 }
1401 }
1402
1403 return 0;
1404}
1405
1406/*
1407 * Internal done function
1408 *
1409 */
1410static void done(struct Scsi_Host *shpnt, int error)
1411{
1412 if (CURRENT_SC) {
1413 if(DONE_SC)
1414 printk(ERR_LEAD "there's already a completed command %p - will cause abort\n", CMDINFO(CURRENT_SC), DONE_SC);
1415
1416 DONE_SC = CURRENT_SC;
1417 CURRENT_SC = NULL;
1418 DONE_SC->result = error;
1419 } else
1420 printk(KERN_ERR "aha152x: done() called outside of command\n");
1421}
1422
1423static struct work_struct aha152x_tq;
1424
1425/*
1426 * Run service completions on the card with interrupts enabled.
1427 *
1428 */
1429static void run(struct work_struct *work)
1430{
1431 struct aha152x_hostdata *hd;
1432
1433 list_for_each_entry(hd, &aha152x_host_list, host_list) {
1434 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
1435
1436 is_complete(shost);
1437 }
1438}
1439
1440/*
1441 * Interrupt handler
1442 *
1443 */
1444static irqreturn_t intr(int irqno, void *dev_id)
1445{
1446 struct Scsi_Host *shpnt = dev_id;
1447 unsigned long flags;
1448 unsigned char rev, dmacntrl0;
1449
1450 /*
1451 * Read a couple of registers that are known to not be all 1's. If
1452 * we read all 1's (-1), that means that either:
1453 *
1454 * a. The host adapter chip has gone bad, and we cannot control it,
1455 * OR
1456 * b. The host adapter is a PCMCIA card that has been ejected
1457 *
1458 * In either case, we cannot do anything with the host adapter at
1459 * this point in time. So just ignore the interrupt and return.
1460 * In the latter case, the interrupt might actually be meant for
1461 * someone else sharing this IRQ, and that driver will handle it.
1462 */
1463 rev = GETPORT(REV);
1464 dmacntrl0 = GETPORT(DMACNTRL0);
1465 if ((rev == 0xFF) && (dmacntrl0 == 0xFF))
1466 return IRQ_NONE;
1467
1468 if( TESTLO(DMASTAT, INTSTAT) )
1469 return IRQ_NONE;
1470
1471 /* no more interrupts from the controller, while we're busy.
1472 INTEN is restored by the BH handler */
1473 CLRBITS(DMACNTRL0, INTEN);
1474
1475 DO_LOCK(flags);
1476 if( HOSTDATA(shpnt)->service==0 ) {
1477 HOSTDATA(shpnt)->service=1;
1478
1479 /* Poke the BH handler */
1480 INIT_WORK(&aha152x_tq, run);
1481 schedule_work(&aha152x_tq);
1482 }
1483 DO_UNLOCK(flags);
1484
1485 return IRQ_HANDLED;
1486}
1487
1488/*
1489 * busfree phase
1490 * - handle completition/disconnection/error of current command
1491 * - start selection for next command (if any)
1492 */
1493static void busfree_run(struct Scsi_Host *shpnt)
1494{
1495 unsigned long flags;
1496#if defined(AHA152X_STAT)
1497 int action=0;
1498#endif
1499
1500 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
1501 SETPORT(SXFRCTL0, CH1);
1502
1503 SETPORT(SSTAT1, CLRBUSFREE);
1504
1505 if(CURRENT_SC) {
1506#if defined(AHA152X_STAT)
1507 action++;
1508#endif
1509 CURRENT_SC->SCp.phase &= ~syncneg;
1510
1511 if(CURRENT_SC->SCp.phase & completed) {
1512 /* target sent COMMAND COMPLETE */
1513 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_OK << 16));
1514
1515 } else if(CURRENT_SC->SCp.phase & aborted) {
1516 DPRINTK(debug_eh, DEBUG_LEAD "ABORT sent\n", CMDINFO(CURRENT_SC));
1517 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_ABORT << 16));
1518
1519 } else if(CURRENT_SC->SCp.phase & resetted) {
1520 DPRINTK(debug_eh, DEBUG_LEAD "BUS DEVICE RESET sent\n", CMDINFO(CURRENT_SC));
1521 done(shpnt, (CURRENT_SC->SCp.Status & 0xff) | ((CURRENT_SC->SCp.Message & 0xff) << 8) | (DID_RESET << 16));
1522
1523 } else if(CURRENT_SC->SCp.phase & disconnected) {
1524 /* target sent DISCONNECT */
1525 DPRINTK(debug_selection, DEBUG_LEAD "target disconnected at %d/%d\n",
1526 CMDINFO(CURRENT_SC),
1527 scsi_get_resid(CURRENT_SC),
1528 scsi_bufflen(CURRENT_SC));
1529#if defined(AHA152X_STAT)
1530 HOSTDATA(shpnt)->disconnections++;
1531#endif
1532 append_SC(&DISCONNECTED_SC, CURRENT_SC);
1533 CURRENT_SC->SCp.phase |= 1 << 16;
1534 CURRENT_SC = NULL;
1535
1536 } else {
1537 done(shpnt, DID_ERROR << 16);
1538 }
1539#if defined(AHA152X_STAT)
1540 } else {
1541 HOSTDATA(shpnt)->busfree_without_old_command++;
1542#endif
1543 }
1544
1545 DO_LOCK(flags);
1546
1547 if(DONE_SC) {
1548#if defined(AHA152X_STAT)
1549 action++;
1550#endif
1551
1552 if(DONE_SC->SCp.phase & check_condition) {
1553 struct scsi_cmnd *cmd = HOSTDATA(shpnt)->done_SC;
1554 struct aha152x_scdata *sc = SCDATA(cmd);
1555
1556#if 0
1557 if(HOSTDATA(shpnt)->debug & debug_eh) {
1558 printk(ERR_LEAD "received sense: ", CMDINFO(DONE_SC));
1559 scsi_print_sense("bh", DONE_SC);
1560 }
1561#endif
1562
1563 scsi_eh_restore_cmnd(cmd, &sc->ses);
1564
1565 cmd->SCp.Status = SAM_STAT_CHECK_CONDITION;
1566
1567 HOSTDATA(shpnt)->commands--;
1568 if (!HOSTDATA(shpnt)->commands)
1569 SETPORT(PORTA, 0); /* turn led off */
1570 } else if(DONE_SC->SCp.Status==SAM_STAT_CHECK_CONDITION) {
1571#if defined(AHA152X_STAT)
1572 HOSTDATA(shpnt)->busfree_with_check_condition++;
1573#endif
1574#if 0
1575 DPRINTK(debug_eh, ERR_LEAD "CHECK CONDITION found\n", CMDINFO(DONE_SC));
1576#endif
1577
1578 if(!(DONE_SC->SCp.phase & not_issued)) {
1579 struct aha152x_scdata *sc;
1580 Scsi_Cmnd *ptr = DONE_SC;
1581 DONE_SC=NULL;
1582#if 0
1583 DPRINTK(debug_eh, ERR_LEAD "requesting sense\n", CMDINFO(ptr));
1584#endif
1585
1586 sc = SCDATA(ptr);
1587 /* It was allocated in aha152x_internal_queue? */
1588 BUG_ON(!sc);
1589 scsi_eh_prep_cmnd(ptr, &sc->ses, NULL, 0, ~0);
1590
1591 DO_UNLOCK(flags);
1592 aha152x_internal_queue(ptr, NULL, check_condition, ptr->scsi_done);
1593 DO_LOCK(flags);
1594#if 0
1595 } else {
1596 DPRINTK(debug_eh, ERR_LEAD "command not issued - CHECK CONDITION ignored\n", CMDINFO(DONE_SC));
1597#endif
1598 }
1599 }
1600
1601 if(DONE_SC && DONE_SC->scsi_done) {
1602#if defined(AHA152X_DEBUG)
1603 int hostno=DONE_SC->device->host->host_no;
1604 int id=DONE_SC->device->id & 0xf;
1605 int lun=DONE_SC->device->lun & 0x7;
1606#endif
1607 Scsi_Cmnd *ptr = DONE_SC;
1608 DONE_SC=NULL;
1609
1610 /* turn led off, when no commands are in the driver */
1611 HOSTDATA(shpnt)->commands--;
1612 if (!HOSTDATA(shpnt)->commands)
1613 SETPORT(PORTA, 0); /* turn led off */
1614
1615 if(ptr->scsi_done != reset_done) {
1616 kfree(ptr->host_scribble);
1617 ptr->host_scribble=NULL;
1618 }
1619
1620 DO_UNLOCK(flags);
1621 DPRINTK(debug_done, DEBUG_LEAD "calling scsi_done(%p)\n", hostno, id, lun, ptr);
1622 ptr->scsi_done(ptr);
1623 DPRINTK(debug_done, DEBUG_LEAD "scsi_done(%p) returned\n", hostno, id, lun, ptr);
1624 DO_LOCK(flags);
1625 }
1626
1627 DONE_SC=NULL;
1628#if defined(AHA152X_STAT)
1629 } else {
1630 HOSTDATA(shpnt)->busfree_without_done_command++;
1631#endif
1632 }
1633
1634 if(ISSUE_SC)
1635 CURRENT_SC = remove_first_SC(&ISSUE_SC);
1636
1637 DO_UNLOCK(flags);
1638
1639 if(CURRENT_SC) {
1640#if defined(AHA152X_STAT)
1641 action++;
1642#endif
1643 CURRENT_SC->SCp.phase |= selecting;
1644
1645 DPRINTK(debug_selection, DEBUG_LEAD "selecting target\n", CMDINFO(CURRENT_SC));
1646
1647 /* clear selection timeout */
1648 SETPORT(SSTAT1, SELTO);
1649
1650 SETPORT(SCSIID, (shpnt->this_id << OID_) | CURRENT_SC->device->id);
1651 SETPORT(SXFRCTL1, (PARITY ? ENSPCHK : 0 ) | ENSTIMER);
1652 SETPORT(SCSISEQ, ENSELO | ENAUTOATNO | (DISCONNECTED_SC ? ENRESELI : 0));
1653 } else {
1654#if defined(AHA152X_STAT)
1655 HOSTDATA(shpnt)->busfree_without_new_command++;
1656#endif
1657 SETPORT(SCSISEQ, DISCONNECTED_SC ? ENRESELI : 0);
1658 }
1659
1660#if defined(AHA152X_STAT)
1661 if(!action)
1662 HOSTDATA(shpnt)->busfree_without_any_action++;
1663#endif
1664}
1665
1666/*
1667 * Selection done (OUT)
1668 * - queue IDENTIFY message and SDTR to selected target for message out
1669 * (ATN asserted automagically via ENAUTOATNO in busfree())
1670 */
1671static void seldo_run(struct Scsi_Host *shpnt)
1672{
1673 SETPORT(SCSISIG, 0);
1674 SETPORT(SSTAT1, CLRBUSFREE);
1675 SETPORT(SSTAT1, CLRPHASECHG);
1676
1677 CURRENT_SC->SCp.phase &= ~(selecting|not_issued);
1678
1679 SETPORT(SCSISEQ, 0);
1680
1681 if (TESTLO(SSTAT0, SELDO)) {
1682 printk(ERR_LEAD "aha152x: passing bus free condition\n", CMDINFO(CURRENT_SC));
1683 done(shpnt, DID_NO_CONNECT << 16);
1684 return;
1685 }
1686
1687 SETPORT(SSTAT0, CLRSELDO);
1688
1689 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
1690
1691 if (CURRENT_SC->SCp.phase & aborting) {
1692 ADDMSGO(ABORT);
1693 } else if (CURRENT_SC->SCp.phase & resetting) {
1694 ADDMSGO(BUS_DEVICE_RESET);
1695 } else if (SYNCNEG==0 && SYNCHRONOUS) {
1696 CURRENT_SC->SCp.phase |= syncneg;
1697 MSGOLEN += spi_populate_sync_msg(&MSGO(MSGOLEN), 50, 8);
1698 SYNCNEG=1; /* negotiation in progress */
1699 }
1700
1701 SETRATE(SYNCRATE);
1702}
1703
1704/*
1705 * Selection timeout
1706 * - return command to mid-level with failure cause
1707 *
1708 */
1709static void selto_run(struct Scsi_Host *shpnt)
1710{
1711 SETPORT(SCSISEQ, 0);
1712 SETPORT(SSTAT1, CLRSELTIMO);
1713
1714 DPRINTK(debug_selection, DEBUG_LEAD "selection timeout\n", CMDINFO(CURRENT_SC));
1715
1716 if(!CURRENT_SC) {
1717 DPRINTK(debug_selection, DEBUG_LEAD "!CURRENT_SC\n", CMDINFO(CURRENT_SC));
1718 return;
1719 }
1720
1721 CURRENT_SC->SCp.phase &= ~selecting;
1722
1723 if (CURRENT_SC->SCp.phase & aborted) {
1724 DPRINTK(debug_selection, DEBUG_LEAD "aborted\n", CMDINFO(CURRENT_SC));
1725 done(shpnt, DID_ABORT << 16);
1726 } else if (TESTLO(SSTAT0, SELINGO)) {
1727 DPRINTK(debug_selection, DEBUG_LEAD "arbitration not won\n", CMDINFO(CURRENT_SC));
1728 done(shpnt, DID_BUS_BUSY << 16);
1729 } else {
1730 /* ARBITRATION won, but SELECTION failed */
1731 DPRINTK(debug_selection, DEBUG_LEAD "selection failed\n", CMDINFO(CURRENT_SC));
1732 done(shpnt, DID_NO_CONNECT << 16);
1733 }
1734}
1735
1736/*
1737 * Selection in done
1738 * - put current command back to issue queue
1739 * (reconnection of a disconnected nexus instead
1740 * of successful selection out)
1741 *
1742 */
1743static void seldi_run(struct Scsi_Host *shpnt)
1744{
1745 int selid;
1746 int target;
1747 unsigned long flags;
1748
1749 SETPORT(SCSISIG, 0);
1750 SETPORT(SSTAT0, CLRSELDI);
1751 SETPORT(SSTAT1, CLRBUSFREE);
1752 SETPORT(SSTAT1, CLRPHASECHG);
1753
1754 if(CURRENT_SC) {
1755 if(!(CURRENT_SC->SCp.phase & not_issued))
1756 printk(ERR_LEAD "command should not have been issued yet\n", CMDINFO(CURRENT_SC));
1757
1758 DPRINTK(debug_selection, ERR_LEAD "command requeued - reselection\n", CMDINFO(CURRENT_SC));
1759
1760 DO_LOCK(flags);
1761 append_SC(&ISSUE_SC, CURRENT_SC);
1762 DO_UNLOCK(flags);
1763
1764 CURRENT_SC = NULL;
1765 }
1766
1767 if(!DISCONNECTED_SC) {
1768 DPRINTK(debug_selection, DEBUG_LEAD "unexpected SELDI ", CMDINFO(CURRENT_SC));
1769 return;
1770 }
1771
1772 RECONN_TARGET=-1;
1773
1774 selid = GETPORT(SELID) & ~(1 << shpnt->this_id);
1775
1776 if (selid==0) {
1777 printk("aha152x%d: target id unknown (%02x)\n", HOSTNO, selid);
1778 return;
1779 }
1780
1781 for(target=7; !(selid & (1 << target)); target--)
1782 ;
1783
1784 if(selid & ~(1 << target)) {
1785 printk("aha152x%d: multiple targets reconnected (%02x)\n",
1786 HOSTNO, selid);
1787 }
1788
1789
1790 SETPORT(SCSIID, (shpnt->this_id << OID_) | target);
1791 SETPORT(SCSISEQ, 0);
1792
1793 SETRATE(HOSTDATA(shpnt)->syncrate[target]);
1794
1795 RECONN_TARGET=target;
1796 DPRINTK(debug_selection, DEBUG_LEAD "target %d reselected (%02x).\n", CMDINFO(CURRENT_SC), target, selid);
1797}
1798
1799/*
1800 * message in phase
1801 * - handle initial message after reconnection to identify
1802 * reconnecting nexus
1803 * - queue command on DISCONNECTED_SC on DISCONNECT message
1804 * - set completed flag on COMMAND COMPLETE
1805 * (other completition code moved to busfree_run)
1806 * - handle response to SDTR
1807 * - clear synchronous transfer agreements on BUS RESET
1808 *
1809 * FIXME: what about SAVE POINTERS, RESTORE POINTERS?
1810 *
1811 */
1812static void msgi_run(struct Scsi_Host *shpnt)
1813{
1814 for(;;) {
1815 int sstat1 = GETPORT(SSTAT1);
1816
1817 if(sstat1 & (PHASECHG|PHASEMIS|BUSFREE) || !(sstat1 & REQINIT))
1818 return;
1819
1820 if(TESTLO(SSTAT0,SPIORDY)) {
1821 DPRINTK(debug_msgi, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
1822 return;
1823 }
1824
1825 ADDMSGI(GETPORT(SCSIDAT));
1826
1827#if defined(AHA152X_DEBUG)
1828 if (HOSTDATA(shpnt)->debug & debug_msgi) {
1829 printk(INFO_LEAD "inbound message %02x ", CMDINFO(CURRENT_SC), MSGI(0));
1830 spi_print_msg(&MSGI(0));
1831 printk("\n");
1832 }
1833#endif
1834
1835 if(!CURRENT_SC) {
1836 if(LASTSTATE!=seldi) {
1837 printk(KERN_ERR "aha152x%d: message in w/o current command not after reselection\n", HOSTNO);
1838 }
1839
1840 /*
1841 * Handle reselection
1842 */
1843 if(!(MSGI(0) & IDENTIFY_BASE)) {
1844 printk(KERN_ERR "aha152x%d: target didn't identify after reselection\n", HOSTNO);
1845 continue;
1846 }
1847
1848 CURRENT_SC = remove_lun_SC(&DISCONNECTED_SC, RECONN_TARGET, MSGI(0) & 0x3f);
1849
1850 if (!CURRENT_SC) {
1851 show_queues(shpnt);
1852 printk(KERN_ERR "aha152x%d: no disconnected command for target %d/%d\n", HOSTNO, RECONN_TARGET, MSGI(0) & 0x3f);
1853 continue;
1854 }
1855
1856 DPRINTK(debug_msgi, DEBUG_LEAD "target reconnected\n", CMDINFO(CURRENT_SC));
1857
1858 CURRENT_SC->SCp.Message = MSGI(0);
1859 CURRENT_SC->SCp.phase &= ~disconnected;
1860
1861 MSGILEN=0;
1862
1863 /* next message if any */
1864 continue;
1865 }
1866
1867 CURRENT_SC->SCp.Message = MSGI(0);
1868
1869 switch (MSGI(0)) {
1870 case DISCONNECT:
1871 if (!RECONNECT)
1872 printk(WARN_LEAD "target was not allowed to disconnect\n", CMDINFO(CURRENT_SC));
1873
1874 CURRENT_SC->SCp.phase |= disconnected;
1875 break;
1876
1877 case COMMAND_COMPLETE:
1878 if(CURRENT_SC->SCp.phase & completed)
1879 DPRINTK(debug_msgi, DEBUG_LEAD "again COMMAND COMPLETE\n", CMDINFO(CURRENT_SC));
1880
1881 CURRENT_SC->SCp.phase |= completed;
1882 break;
1883
1884 case MESSAGE_REJECT:
1885 if (SYNCNEG==1) {
1886 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
1887 SYNCNEG=2; /* negotiation completed */
1888 } else
1889 printk(INFO_LEAD "inbound message (MESSAGE REJECT)\n", CMDINFO(CURRENT_SC));
1890 break;
1891
1892 case SAVE_POINTERS:
1893 break;
1894
1895 case RESTORE_POINTERS:
1896 break;
1897
1898 case EXTENDED_MESSAGE:
1899 if(MSGILEN<2 || MSGILEN<MSGI(1)+2) {
1900 /* not yet completed */
1901 continue;
1902 }
1903
1904 switch (MSGI(2)) {
1905 case EXTENDED_SDTR:
1906 {
1907 long ticks;
1908
1909 if (MSGI(1) != 3) {
1910 printk(ERR_LEAD "SDTR message length!=3\n", CMDINFO(CURRENT_SC));
1911 break;
1912 }
1913
1914 if (!HOSTDATA(shpnt)->synchronous)
1915 break;
1916
1917 printk(INFO_LEAD, CMDINFO(CURRENT_SC));
1918 spi_print_msg(&MSGI(0));
1919 printk("\n");
1920
1921 ticks = (MSGI(3) * 4 + 49) / 50;
1922
1923 if (syncneg) {
1924 /* negotiation in progress */
1925 if (ticks > 9 || MSGI(4) < 1 || MSGI(4) > 8) {
1926 ADDMSGO(MESSAGE_REJECT);
1927 printk(INFO_LEAD "received Synchronous Data Transfer Request invalid - rejected\n", CMDINFO(CURRENT_SC));
1928 break;
1929 }
1930
1931 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1932 } else if (ticks <= 9 && MSGI(4) >= 1) {
1933 ADDMSGO(EXTENDED_MESSAGE);
1934 ADDMSGO(3);
1935 ADDMSGO(EXTENDED_SDTR);
1936 if (ticks < 4) {
1937 ticks = 4;
1938 ADDMSGO(50);
1939 } else
1940 ADDMSGO(MSGI(3));
1941
1942 if (MSGI(4) > 8)
1943 MSGI(4) = 8;
1944
1945 ADDMSGO(MSGI(4));
1946
1947 SYNCRATE |= ((ticks - 2) << 4) + MSGI(4);
1948 } else {
1949 /* requested SDTR is too slow, do it asynchronously */
1950 printk(INFO_LEAD "Synchronous Data Transfer Request too slow - Rejecting\n", CMDINFO(CURRENT_SC));
1951 ADDMSGO(MESSAGE_REJECT);
1952 }
1953
1954 SYNCNEG=2; /* negotiation completed */
1955 SETRATE(SYNCRATE);
1956 }
1957 break;
1958
1959 case BUS_DEVICE_RESET:
1960 {
1961 int i;
1962
1963 for(i=0; i<8; i++) {
1964 HOSTDATA(shpnt)->syncrate[i]=0;
1965 HOSTDATA(shpnt)->syncneg[i]=0;
1966 }
1967
1968 }
1969 break;
1970
1971 case EXTENDED_MODIFY_DATA_POINTER:
1972 case EXTENDED_EXTENDED_IDENTIFY:
1973 case EXTENDED_WDTR:
1974 default:
1975 ADDMSGO(MESSAGE_REJECT);
1976 break;
1977 }
1978 break;
1979 }
1980
1981 MSGILEN=0;
1982 }
1983}
1984
1985static void msgi_end(struct Scsi_Host *shpnt)
1986{
1987 if(MSGILEN>0)
1988 printk(WARN_LEAD "target left before message completed (%d)\n", CMDINFO(CURRENT_SC), MSGILEN);
1989
1990 if (MSGOLEN > 0 && !(GETPORT(SSTAT1) & BUSFREE)) {
1991 DPRINTK(debug_msgi, DEBUG_LEAD "msgo pending\n", CMDINFO(CURRENT_SC));
1992 SETPORT(SCSISIG, P_MSGI | SIG_ATNO);
1993 }
1994}
1995
1996/*
1997 * message out phase
1998 *
1999 */
2000static void msgo_init(struct Scsi_Host *shpnt)
2001{
2002 if(MSGOLEN==0) {
2003 if((CURRENT_SC->SCp.phase & syncneg) && SYNCNEG==2 && SYNCRATE==0) {
2004 ADDMSGO(IDENTIFY(RECONNECT, CURRENT_SC->device->lun));
2005 } else {
2006 printk(INFO_LEAD "unexpected MESSAGE OUT phase; rejecting\n", CMDINFO(CURRENT_SC));
2007 ADDMSGO(MESSAGE_REJECT);
2008 }
2009 }
2010
2011#if defined(AHA152X_DEBUG)
2012 if(HOSTDATA(shpnt)->debug & debug_msgo) {
2013 int i;
2014
2015 printk(DEBUG_LEAD "messages( ", CMDINFO(CURRENT_SC));
2016 for (i=0; i<MSGOLEN; i+=spi_print_msg(&MSGO(i)), printk(" "))
2017 ;
2018 printk(")\n");
2019 }
2020#endif
2021}
2022
2023/*
2024 * message out phase
2025 *
2026 */
2027static void msgo_run(struct Scsi_Host *shpnt)
2028{
2029 if(MSGO_I==MSGOLEN)
2030 DPRINTK(debug_msgo, DEBUG_LEAD "messages all sent (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2031
2032 while(MSGO_I<MSGOLEN) {
2033 DPRINTK(debug_msgo, DEBUG_LEAD "message byte %02x (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO(MSGO_I), MSGO_I, MSGOLEN);
2034
2035 if(TESTLO(SSTAT0, SPIORDY)) {
2036 DPRINTK(debug_msgo, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2037 return;
2038 }
2039
2040 if (MSGO_I==MSGOLEN-1) {
2041 /* Leave MESSAGE OUT after transfer */
2042 SETPORT(SSTAT1, CLRATNO);
2043 }
2044
2045
2046 if (MSGO(MSGO_I) & IDENTIFY_BASE)
2047 CURRENT_SC->SCp.phase |= identified;
2048
2049 if (MSGO(MSGO_I)==ABORT)
2050 CURRENT_SC->SCp.phase |= aborted;
2051
2052 if (MSGO(MSGO_I)==BUS_DEVICE_RESET)
2053 CURRENT_SC->SCp.phase |= resetted;
2054
2055 SETPORT(SCSIDAT, MSGO(MSGO_I++));
2056 }
2057}
2058
2059static void msgo_end(struct Scsi_Host *shpnt)
2060{
2061 if(MSGO_I<MSGOLEN) {
2062 printk(ERR_LEAD "message sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), MSGO_I, MSGOLEN);
2063 if(SYNCNEG==1) {
2064 printk(INFO_LEAD "Synchronous Data Transfer Request was rejected\n", CMDINFO(CURRENT_SC));
2065 SYNCNEG=2;
2066 }
2067 }
2068
2069 MSGO_I = 0;
2070 MSGOLEN = 0;
2071}
2072
2073/*
2074 * command phase
2075 *
2076 */
2077static void cmd_init(struct Scsi_Host *shpnt)
2078{
2079 if (CURRENT_SC->SCp.sent_command) {
2080 printk(ERR_LEAD "command already sent\n", CMDINFO(CURRENT_SC));
2081 done(shpnt, DID_ERROR << 16);
2082 return;
2083 }
2084
2085#if defined(AHA152X_DEBUG)
2086 if (HOSTDATA(shpnt)->debug & debug_cmd) {
2087 printk(DEBUG_LEAD "cmd_init: ", CMDINFO(CURRENT_SC));
2088 __scsi_print_command(CURRENT_SC->cmnd);
2089 }
2090#endif
2091
2092 CMD_I=0;
2093}
2094
2095/*
2096 * command phase
2097 *
2098 */
2099static void cmd_run(struct Scsi_Host *shpnt)
2100{
2101 if(CMD_I==CURRENT_SC->cmd_len) {
2102 DPRINTK(debug_cmd, DEBUG_LEAD "command already completely sent (%d/%d)", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2103 disp_ports(shpnt);
2104 }
2105
2106 while(CMD_I<CURRENT_SC->cmd_len) {
2107 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);
2108
2109 if(TESTLO(SSTAT0, SPIORDY)) {
2110 DPRINTK(debug_cmd, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2111 return;
2112 }
2113
2114 SETPORT(SCSIDAT, CURRENT_SC->cmnd[CMD_I++]);
2115 }
2116}
2117
2118static void cmd_end(struct Scsi_Host *shpnt)
2119{
2120 if(CMD_I<CURRENT_SC->cmd_len)
2121 printk(ERR_LEAD "command sent incompletely (%d/%d)\n", CMDINFO(CURRENT_SC), CMD_I, CURRENT_SC->cmd_len);
2122 else
2123 CURRENT_SC->SCp.sent_command++;
2124}
2125
2126/*
2127 * status phase
2128 *
2129 */
2130static void status_run(struct Scsi_Host *shpnt)
2131{
2132 if(TESTLO(SSTAT0,SPIORDY)) {
2133 DPRINTK(debug_status, DEBUG_LEAD "!SPIORDY\n", CMDINFO(CURRENT_SC));
2134 return;
2135 }
2136
2137 CURRENT_SC->SCp.Status = GETPORT(SCSIDAT);
2138
2139#if defined(AHA152X_DEBUG)
2140 if (HOSTDATA(shpnt)->debug & debug_status) {
2141 printk(DEBUG_LEAD "inbound status %02x ", CMDINFO(CURRENT_SC), CURRENT_SC->SCp.Status);
2142 scsi_print_status(CURRENT_SC->SCp.Status);
2143 printk("\n");
2144 }
2145#endif
2146}
2147
2148/*
2149 * data in phase
2150 *
2151 */
2152static void datai_init(struct Scsi_Host *shpnt)
2153{
2154 SETPORT(DMACNTRL0, RSTFIFO);
2155 SETPORT(DMACNTRL0, RSTFIFO|ENDMA);
2156
2157 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2158 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2159
2160 SETPORT(SIMODE0, 0);
2161 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE);
2162
2163 DATA_LEN=0;
2164 DPRINTK(debug_datai,
2165 DEBUG_LEAD "datai_init: request_bufflen=%d resid=%d\n",
2166 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2167 scsi_get_resid(CURRENT_SC));
2168}
2169
2170static void datai_run(struct Scsi_Host *shpnt)
2171{
2172 unsigned long the_time;
2173 int fifodata, data_count;
2174
2175 /*
2176 * loop while the phase persists or the fifos are not empty
2177 *
2178 */
2179 while(TESTLO(DMASTAT, INTSTAT) || TESTLO(DMASTAT, DFIFOEMP) || TESTLO(SSTAT2, SEMPTY)) {
2180 /* FIXME: maybe this should be done by setting up
2181 * STCNT to trigger ENSWRAP interrupt, instead of
2182 * polling for DFIFOFULL
2183 */
2184 the_time=jiffies + 100*HZ;
2185 while(TESTLO(DMASTAT, DFIFOFULL|INTSTAT) && time_before(jiffies,the_time))
2186 barrier();
2187
2188 if(TESTLO(DMASTAT, DFIFOFULL|INTSTAT)) {
2189 printk(ERR_LEAD "datai timeout", CMDINFO(CURRENT_SC));
2190 disp_ports(shpnt);
2191 break;
2192 }
2193
2194 if(TESTHI(DMASTAT, DFIFOFULL)) {
2195 fifodata = 128;
2196 } else {
2197 the_time=jiffies + 100*HZ;
2198 while(TESTLO(SSTAT2, SEMPTY) && time_before(jiffies,the_time))
2199 barrier();
2200
2201 if(TESTLO(SSTAT2, SEMPTY)) {
2202 printk(ERR_LEAD "datai sempty timeout", CMDINFO(CURRENT_SC));
2203 disp_ports(shpnt);
2204 break;
2205 }
2206
2207 fifodata = GETPORT(FIFOSTAT);
2208 }
2209
2210 if(CURRENT_SC->SCp.this_residual>0) {
2211 while(fifodata>0 && CURRENT_SC->SCp.this_residual>0) {
2212 data_count = fifodata>CURRENT_SC->SCp.this_residual ?
2213 CURRENT_SC->SCp.this_residual :
2214 fifodata;
2215 fifodata -= data_count;
2216
2217 if(data_count & 1) {
2218 DPRINTK(debug_datai, DEBUG_LEAD "8bit\n", CMDINFO(CURRENT_SC));
2219 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2220 *CURRENT_SC->SCp.ptr++ = GETPORT(DATAPORT);
2221 CURRENT_SC->SCp.this_residual--;
2222 DATA_LEN++;
2223 SETPORT(DMACNTRL0, ENDMA);
2224 }
2225
2226 if(data_count > 1) {
2227 DPRINTK(debug_datai, DEBUG_LEAD "16bit(%d)\n", CMDINFO(CURRENT_SC), data_count);
2228 data_count >>= 1;
2229 insw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2230 CURRENT_SC->SCp.ptr += 2 * data_count;
2231 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2232 DATA_LEN += 2 * data_count;
2233 }
2234
2235 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2236 /* advance to next buffer */
2237 CURRENT_SC->SCp.buffers_residual--;
2238 CURRENT_SC->SCp.buffer++;
2239 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2240 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2241 }
2242 }
2243 } else if(fifodata>0) {
2244 printk(ERR_LEAD "no buffers left for %d(%d) bytes (data overrun!?)\n", CMDINFO(CURRENT_SC), fifodata, GETPORT(FIFOSTAT));
2245 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2246 while(fifodata>0) {
2247 int data;
2248 data=GETPORT(DATAPORT);
2249 DPRINTK(debug_datai, DEBUG_LEAD "data=%02x\n", CMDINFO(CURRENT_SC), data);
2250 fifodata--;
2251 DATA_LEN++;
2252 }
2253 SETPORT(DMACNTRL0, ENDMA|_8BIT);
2254 }
2255 }
2256
2257 if(TESTLO(DMASTAT, INTSTAT) ||
2258 TESTLO(DMASTAT, DFIFOEMP) ||
2259 TESTLO(SSTAT2, SEMPTY) ||
2260 GETPORT(FIFOSTAT)>0) {
2261 /*
2262 * something went wrong, if there's something left in the fifos
2263 * or the phase didn't change
2264 */
2265 printk(ERR_LEAD "fifos should be empty and phase should have changed\n", CMDINFO(CURRENT_SC));
2266 disp_ports(shpnt);
2267 }
2268
2269 if(DATA_LEN!=GETSTCNT()) {
2270 printk(ERR_LEAD
2271 "manual transfer count differs from automatic (count=%d;stcnt=%d;diff=%d;fifostat=%d)",
2272 CMDINFO(CURRENT_SC), DATA_LEN, GETSTCNT(), GETSTCNT()-DATA_LEN, GETPORT(FIFOSTAT));
2273 disp_ports(shpnt);
2274 mdelay(10000);
2275 }
2276}
2277
2278static void datai_end(struct Scsi_Host *shpnt)
2279{
2280 CMD_INC_RESID(CURRENT_SC, -GETSTCNT());
2281
2282 DPRINTK(debug_datai,
2283 DEBUG_LEAD "datai_end: request_bufflen=%d resid=%d stcnt=%d\n",
2284 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2285 scsi_get_resid(CURRENT_SC), GETSTCNT());
2286
2287 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2288 SETPORT(DMACNTRL0, 0);
2289}
2290
2291/*
2292 * data out phase
2293 *
2294 */
2295static void datao_init(struct Scsi_Host *shpnt)
2296{
2297 SETPORT(DMACNTRL0, WRITE_READ | RSTFIFO);
2298 SETPORT(DMACNTRL0, WRITE_READ | ENDMA);
2299
2300 SETPORT(SXFRCTL0, CH1|CLRSTCNT);
2301 SETPORT(SXFRCTL0, CH1|SCSIEN|DMAEN);
2302
2303 SETPORT(SIMODE0, 0);
2304 SETPORT(SIMODE1, ENSCSIPERR | ENSCSIRST | ENPHASEMIS | ENBUSFREE );
2305
2306 DATA_LEN = scsi_get_resid(CURRENT_SC);
2307
2308 DPRINTK(debug_datao,
2309 DEBUG_LEAD "datao_init: request_bufflen=%d; resid=%d\n",
2310 CMDINFO(CURRENT_SC), scsi_bufflen(CURRENT_SC),
2311 scsi_get_resid(CURRENT_SC));
2312}
2313
2314static void datao_run(struct Scsi_Host *shpnt)
2315{
2316 unsigned long the_time;
2317 int data_count;
2318
2319 /* until phase changes or all data sent */
2320 while(TESTLO(DMASTAT, INTSTAT) && CURRENT_SC->SCp.this_residual>0) {
2321 data_count = 128;
2322 if(data_count > CURRENT_SC->SCp.this_residual)
2323 data_count=CURRENT_SC->SCp.this_residual;
2324
2325 if(TESTLO(DMASTAT, DFIFOEMP)) {
2326 printk(ERR_LEAD "datao fifo not empty (%d)", CMDINFO(CURRENT_SC), GETPORT(FIFOSTAT));
2327 disp_ports(shpnt);
2328 break;
2329 }
2330
2331 if(data_count & 1) {
2332 SETPORT(DMACNTRL0,WRITE_READ|ENDMA|_8BIT);
2333 SETPORT(DATAPORT, *CURRENT_SC->SCp.ptr++);
2334 CURRENT_SC->SCp.this_residual--;
2335 CMD_INC_RESID(CURRENT_SC, -1);
2336 SETPORT(DMACNTRL0,WRITE_READ|ENDMA);
2337 }
2338
2339 if(data_count > 1) {
2340 data_count >>= 1;
2341 outsw(DATAPORT, CURRENT_SC->SCp.ptr, data_count);
2342 CURRENT_SC->SCp.ptr += 2 * data_count;
2343 CURRENT_SC->SCp.this_residual -= 2 * data_count;
2344 CMD_INC_RESID(CURRENT_SC, -2 * data_count);
2345 }
2346
2347 if(CURRENT_SC->SCp.this_residual==0 && CURRENT_SC->SCp.buffers_residual>0) {
2348 /* advance to next buffer */
2349 CURRENT_SC->SCp.buffers_residual--;
2350 CURRENT_SC->SCp.buffer++;
2351 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer);
2352 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length;
2353 }
2354
2355 the_time=jiffies + 100*HZ;
2356 while(TESTLO(DMASTAT, DFIFOEMP|INTSTAT) && time_before(jiffies,the_time))
2357 barrier();
2358
2359 if(TESTLO(DMASTAT, DFIFOEMP|INTSTAT)) {
2360 printk(ERR_LEAD "dataout timeout", CMDINFO(CURRENT_SC));
2361 disp_ports(shpnt);
2362 break;
2363 }
2364 }
2365}
2366
2367static void datao_end(struct Scsi_Host *shpnt)
2368{
2369 if(TESTLO(DMASTAT, DFIFOEMP)) {
2370 int data_count = (DATA_LEN - scsi_get_resid(CURRENT_SC)) -
2371 GETSTCNT();
2372
2373 DPRINTK(debug_datao, DEBUG_LEAD "datao: %d bytes to resend (%d written, %d transferred)\n",
2374 CMDINFO(CURRENT_SC),
2375 data_count,
2376 DATA_LEN - scsi_get_resid(CURRENT_SC),
2377 GETSTCNT());
2378
2379 CMD_INC_RESID(CURRENT_SC, data_count);
2380
2381 data_count -= CURRENT_SC->SCp.ptr -
2382 SG_ADDRESS(CURRENT_SC->SCp.buffer);
2383 while(data_count>0) {
2384 CURRENT_SC->SCp.buffer--;
2385 CURRENT_SC->SCp.buffers_residual++;
2386 data_count -= CURRENT_SC->SCp.buffer->length;
2387 }
2388 CURRENT_SC->SCp.ptr = SG_ADDRESS(CURRENT_SC->SCp.buffer) -
2389 data_count;
2390 CURRENT_SC->SCp.this_residual = CURRENT_SC->SCp.buffer->length +
2391 data_count;
2392 }
2393
2394 DPRINTK(debug_datao, DEBUG_LEAD "datao_end: request_bufflen=%d; resid=%d; stcnt=%d\n",
2395 CMDINFO(CURRENT_SC),
2396 scsi_bufflen(CURRENT_SC),
2397 scsi_get_resid(CURRENT_SC),
2398 GETSTCNT());
2399
2400 SETPORT(SXFRCTL0, CH1|CLRCH1|CLRSTCNT);
2401 SETPORT(SXFRCTL0, CH1);
2402
2403 SETPORT(DMACNTRL0, 0);
2404}
2405
2406/*
2407 * figure out what state we're in
2408 *
2409 */
2410static int update_state(struct Scsi_Host *shpnt)
2411{
2412 int dataphase=0;
2413 unsigned int stat0 = GETPORT(SSTAT0);
2414 unsigned int stat1 = GETPORT(SSTAT1);
2415
2416 PREVSTATE = STATE;
2417 STATE=unknown;
2418
2419 if(stat1 & SCSIRSTI) {
2420 STATE=rsti;
2421 SETPORT(SCSISEQ,0);
2422 SETPORT(SSTAT1,SCSIRSTI);
2423 } else if(stat0 & SELDI && PREVSTATE==busfree) {
2424 STATE=seldi;
2425 } else if(stat0 & SELDO && CURRENT_SC && (CURRENT_SC->SCp.phase & selecting)) {
2426 STATE=seldo;
2427 } else if(stat1 & SELTO) {
2428 STATE=selto;
2429 } else if(stat1 & BUSFREE) {
2430 STATE=busfree;
2431 SETPORT(SSTAT1,BUSFREE);
2432 } else if(stat1 & SCSIPERR) {
2433 STATE=parerr;
2434 SETPORT(SSTAT1,SCSIPERR);
2435 } else if(stat1 & REQINIT) {
2436 switch(GETPORT(SCSISIG) & P_MASK) {
2437 case P_MSGI: STATE=msgi; break;
2438 case P_MSGO: STATE=msgo; break;
2439 case P_DATAO: STATE=datao; break;
2440 case P_DATAI: STATE=datai; break;
2441 case P_STATUS: STATE=status; break;
2442 case P_CMD: STATE=cmd; break;
2443 }
2444 dataphase=1;
2445 }
2446
2447 if((stat0 & SELDI) && STATE!=seldi && !dataphase) {
2448 printk(INFO_LEAD "reselection missed?", CMDINFO(CURRENT_SC));
2449 disp_ports(shpnt);
2450 }
2451
2452 if(STATE!=PREVSTATE) {
2453 LASTSTATE=PREVSTATE;
2454 }
2455
2456 return dataphase;
2457}
2458
2459/*
2460 * handle parity error
2461 *
2462 * FIXME: in which phase?
2463 *
2464 */
2465static void parerr_run(struct Scsi_Host *shpnt)
2466{
2467 printk(ERR_LEAD "parity error\n", CMDINFO(CURRENT_SC));
2468 done(shpnt, DID_PARITY << 16);
2469}
2470
2471/*
2472 * handle reset in
2473 *
2474 */
2475static void rsti_run(struct Scsi_Host *shpnt)
2476{
2477 Scsi_Cmnd *ptr;
2478
2479 printk(KERN_NOTICE "aha152x%d: scsi reset in\n", HOSTNO);
2480
2481 ptr=DISCONNECTED_SC;
2482 while(ptr) {
2483 Scsi_Cmnd *next = SCNEXT(ptr);
2484
2485 if (!ptr->device->soft_reset) {
2486 remove_SC(&DISCONNECTED_SC, ptr);
2487
2488 kfree(ptr->host_scribble);
2489 ptr->host_scribble=NULL;
2490
2491 ptr->result = DID_RESET << 16;
2492 ptr->scsi_done(ptr);
2493 }
2494
2495 ptr = next;
2496 }
2497
2498 if(CURRENT_SC && !CURRENT_SC->device->soft_reset)
2499 done(shpnt, DID_RESET << 16 );
2500}
2501
2502
2503/*
2504 * bottom-half handler
2505 *
2506 */
2507static void is_complete(struct Scsi_Host *shpnt)
2508{
2509 int dataphase;
2510 unsigned long flags;
2511 int pending;
2512
2513 if(!shpnt)
2514 return;
2515
2516 DO_LOCK(flags);
2517
2518 if( HOSTDATA(shpnt)->service==0 ) {
2519 DO_UNLOCK(flags);
2520 return;
2521 }
2522
2523 HOSTDATA(shpnt)->service = 0;
2524
2525 if(HOSTDATA(shpnt)->in_intr) {
2526 DO_UNLOCK(flags);
2527 /* aha152x_error never returns.. */
2528 aha152x_error(shpnt, "bottom-half already running!?");
2529 }
2530 HOSTDATA(shpnt)->in_intr++;
2531
2532 /*
2533 * loop while there are interrupt conditions pending
2534 *
2535 */
2536 do {
2537 unsigned long start = jiffies;
2538 DO_UNLOCK(flags);
2539
2540 dataphase=update_state(shpnt);
2541
2542 DPRINTK(debug_phases, LEAD "start %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2543
2544 /*
2545 * end previous state
2546 *
2547 */
2548 if(PREVSTATE!=STATE && states[PREVSTATE].end)
2549 states[PREVSTATE].end(shpnt);
2550
2551 /*
2552 * disable SPIO mode if previous phase used it
2553 * and this one doesn't
2554 *
2555 */
2556 if(states[PREVSTATE].spio && !states[STATE].spio) {
2557 SETPORT(SXFRCTL0, CH1);
2558 SETPORT(DMACNTRL0, 0);
2559 if(CURRENT_SC)
2560 CURRENT_SC->SCp.phase &= ~spiordy;
2561 }
2562
2563 /*
2564 * accept current dataphase phase
2565 *
2566 */
2567 if(dataphase) {
2568 SETPORT(SSTAT0, REQINIT);
2569 SETPORT(SCSISIG, GETPORT(SCSISIG) & P_MASK);
2570 SETPORT(SSTAT1, PHASECHG);
2571 }
2572
2573 /*
2574 * enable SPIO mode if previous didn't use it
2575 * and this one does
2576 *
2577 */
2578 if(!states[PREVSTATE].spio && states[STATE].spio) {
2579 SETPORT(DMACNTRL0, 0);
2580 SETPORT(SXFRCTL0, CH1|SPIOEN);
2581 if(CURRENT_SC)
2582 CURRENT_SC->SCp.phase |= spiordy;
2583 }
2584
2585 /*
2586 * initialize for new state
2587 *
2588 */
2589 if(PREVSTATE!=STATE && states[STATE].init)
2590 states[STATE].init(shpnt);
2591
2592 /*
2593 * handle current state
2594 *
2595 */
2596 if(states[STATE].run)
2597 states[STATE].run(shpnt);
2598 else
2599 printk(ERR_LEAD "unexpected state (%x)\n", CMDINFO(CURRENT_SC), STATE);
2600
2601 /*
2602 * setup controller to interrupt on
2603 * the next expected condition and
2604 * loop if it's already there
2605 *
2606 */
2607 DO_LOCK(flags);
2608 pending=setup_expected_interrupts(shpnt);
2609#if defined(AHA152X_STAT)
2610 HOSTDATA(shpnt)->count[STATE]++;
2611 if(PREVSTATE!=STATE)
2612 HOSTDATA(shpnt)->count_trans[STATE]++;
2613 HOSTDATA(shpnt)->time[STATE] += jiffies-start;
2614#endif
2615
2616 DPRINTK(debug_phases, LEAD "end %s %s(%s)\n", CMDINFO(CURRENT_SC), states[STATE].name, states[PREVSTATE].name, states[LASTSTATE].name);
2617 } while(pending);
2618
2619 /*
2620 * enable interrupts and leave bottom-half
2621 *
2622 */
2623 HOSTDATA(shpnt)->in_intr--;
2624 SETBITS(DMACNTRL0, INTEN);
2625 DO_UNLOCK(flags);
2626}
2627
2628
2629/*
2630 * Dump the current driver status and panic
2631 */
2632static void aha152x_error(struct Scsi_Host *shpnt, char *msg)
2633{
2634 printk(KERN_EMERG "\naha152x%d: %s\n", HOSTNO, msg);
2635 show_queues(shpnt);
2636 panic("aha152x panic\n");
2637}
2638
2639/*
2640 * Display registers of AIC-6260
2641 */
2642static void disp_ports(struct Scsi_Host *shpnt)
2643{
2644#if defined(AHA152X_DEBUG)
2645 int s;
2646
2647 printk("\n%s: %s(%s) ",
2648 CURRENT_SC ? "busy" : "waiting",
2649 states[STATE].name,
2650 states[PREVSTATE].name);
2651
2652 s = GETPORT(SCSISEQ);
2653 printk("SCSISEQ( ");
2654 if (s & TEMODEO)
2655 printk("TARGET MODE ");
2656 if (s & ENSELO)
2657 printk("SELO ");
2658 if (s & ENSELI)
2659 printk("SELI ");
2660 if (s & ENRESELI)
2661 printk("RESELI ");
2662 if (s & ENAUTOATNO)
2663 printk("AUTOATNO ");
2664 if (s & ENAUTOATNI)
2665 printk("AUTOATNI ");
2666 if (s & ENAUTOATNP)
2667 printk("AUTOATNP ");
2668 if (s & SCSIRSTO)
2669 printk("SCSIRSTO ");
2670 printk(");");
2671
2672 printk(" SCSISIG(");
2673 s = GETPORT(SCSISIG);
2674 switch (s & P_MASK) {
2675 case P_DATAO:
2676 printk("DATA OUT");
2677 break;
2678 case P_DATAI:
2679 printk("DATA IN");
2680 break;
2681 case P_CMD:
2682 printk("COMMAND");
2683 break;
2684 case P_STATUS:
2685 printk("STATUS");
2686 break;
2687 case P_MSGO:
2688 printk("MESSAGE OUT");
2689 break;
2690 case P_MSGI:
2691 printk("MESSAGE IN");
2692 break;
2693 default:
2694 printk("*invalid*");
2695 break;
2696 }
2697
2698 printk("); ");
2699
2700 printk("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
2701
2702 printk("SSTAT( ");
2703 s = GETPORT(SSTAT0);
2704 if (s & TARGET)
2705 printk("TARGET ");
2706 if (s & SELDO)
2707 printk("SELDO ");
2708 if (s & SELDI)
2709 printk("SELDI ");
2710 if (s & SELINGO)
2711 printk("SELINGO ");
2712 if (s & SWRAP)
2713 printk("SWRAP ");
2714 if (s & SDONE)
2715 printk("SDONE ");
2716 if (s & SPIORDY)
2717 printk("SPIORDY ");
2718 if (s & DMADONE)
2719 printk("DMADONE ");
2720
2721 s = GETPORT(SSTAT1);
2722 if (s & SELTO)
2723 printk("SELTO ");
2724 if (s & ATNTARG)
2725 printk("ATNTARG ");
2726 if (s & SCSIRSTI)
2727 printk("SCSIRSTI ");
2728 if (s & PHASEMIS)
2729 printk("PHASEMIS ");
2730 if (s & BUSFREE)
2731 printk("BUSFREE ");
2732 if (s & SCSIPERR)
2733 printk("SCSIPERR ");
2734 if (s & PHASECHG)
2735 printk("PHASECHG ");
2736 if (s & REQINIT)
2737 printk("REQINIT ");
2738 printk("); ");
2739
2740
2741 printk("SSTAT( ");
2742
2743 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
2744
2745 if (s & TARGET)
2746 printk("TARGET ");
2747 if (s & SELDO)
2748 printk("SELDO ");
2749 if (s & SELDI)
2750 printk("SELDI ");
2751 if (s & SELINGO)
2752 printk("SELINGO ");
2753 if (s & SWRAP)
2754 printk("SWRAP ");
2755 if (s & SDONE)
2756 printk("SDONE ");
2757 if (s & SPIORDY)
2758 printk("SPIORDY ");
2759 if (s & DMADONE)
2760 printk("DMADONE ");
2761
2762 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
2763
2764 if (s & SELTO)
2765 printk("SELTO ");
2766 if (s & ATNTARG)
2767 printk("ATNTARG ");
2768 if (s & SCSIRSTI)
2769 printk("SCSIRSTI ");
2770 if (s & PHASEMIS)
2771 printk("PHASEMIS ");
2772 if (s & BUSFREE)
2773 printk("BUSFREE ");
2774 if (s & SCSIPERR)
2775 printk("SCSIPERR ");
2776 if (s & PHASECHG)
2777 printk("PHASECHG ");
2778 if (s & REQINIT)
2779 printk("REQINIT ");
2780 printk("); ");
2781
2782 printk("SXFRCTL0( ");
2783
2784 s = GETPORT(SXFRCTL0);
2785 if (s & SCSIEN)
2786 printk("SCSIEN ");
2787 if (s & DMAEN)
2788 printk("DMAEN ");
2789 if (s & CH1)
2790 printk("CH1 ");
2791 if (s & CLRSTCNT)
2792 printk("CLRSTCNT ");
2793 if (s & SPIOEN)
2794 printk("SPIOEN ");
2795 if (s & CLRCH1)
2796 printk("CLRCH1 ");
2797 printk("); ");
2798
2799 printk("SIGNAL( ");
2800
2801 s = GETPORT(SCSISIG);
2802 if (s & SIG_ATNI)
2803 printk("ATNI ");
2804 if (s & SIG_SELI)
2805 printk("SELI ");
2806 if (s & SIG_BSYI)
2807 printk("BSYI ");
2808 if (s & SIG_REQI)
2809 printk("REQI ");
2810 if (s & SIG_ACKI)
2811 printk("ACKI ");
2812 printk("); ");
2813
2814 printk("SELID (%02x), ", GETPORT(SELID));
2815
2816 printk("STCNT (%d), ", GETSTCNT());
2817
2818 printk("SSTAT2( ");
2819
2820 s = GETPORT(SSTAT2);
2821 if (s & SOFFSET)
2822 printk("SOFFSET ");
2823 if (s & SEMPTY)
2824 printk("SEMPTY ");
2825 if (s & SFULL)
2826 printk("SFULL ");
2827 printk("); SFCNT (%d); ", s & (SFULL | SFCNT));
2828
2829 s = GETPORT(SSTAT3);
2830 printk("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
2831
2832 printk("SSTAT4( ");
2833 s = GETPORT(SSTAT4);
2834 if (s & SYNCERR)
2835 printk("SYNCERR ");
2836 if (s & FWERR)
2837 printk("FWERR ");
2838 if (s & FRERR)
2839 printk("FRERR ");
2840 printk("); ");
2841
2842 printk("DMACNTRL0( ");
2843 s = GETPORT(DMACNTRL0);
2844 printk("%s ", s & _8BIT ? "8BIT" : "16BIT");
2845 printk("%s ", s & DMA ? "DMA" : "PIO");
2846 printk("%s ", s & WRITE_READ ? "WRITE" : "READ");
2847 if (s & ENDMA)
2848 printk("ENDMA ");
2849 if (s & INTEN)
2850 printk("INTEN ");
2851 if (s & RSTFIFO)
2852 printk("RSTFIFO ");
2853 if (s & SWINT)
2854 printk("SWINT ");
2855 printk("); ");
2856
2857 printk("DMASTAT( ");
2858 s = GETPORT(DMASTAT);
2859 if (s & ATDONE)
2860 printk("ATDONE ");
2861 if (s & WORDRDY)
2862 printk("WORDRDY ");
2863 if (s & DFIFOFULL)
2864 printk("DFIFOFULL ");
2865 if (s & DFIFOEMP)
2866 printk("DFIFOEMP ");
2867 printk(")\n");
2868#endif
2869}
2870
2871/*
2872 * display enabled interrupts
2873 */
2874static void disp_enintr(struct Scsi_Host *shpnt)
2875{
2876 int s;
2877
2878 printk(KERN_DEBUG "enabled interrupts ( ");
2879
2880 s = GETPORT(SIMODE0);
2881 if (s & ENSELDO)
2882 printk("ENSELDO ");
2883 if (s & ENSELDI)
2884 printk("ENSELDI ");
2885 if (s & ENSELINGO)
2886 printk("ENSELINGO ");
2887 if (s & ENSWRAP)
2888 printk("ENSWRAP ");
2889 if (s & ENSDONE)
2890 printk("ENSDONE ");
2891 if (s & ENSPIORDY)
2892 printk("ENSPIORDY ");
2893 if (s & ENDMADONE)
2894 printk("ENDMADONE ");
2895
2896 s = GETPORT(SIMODE1);
2897 if (s & ENSELTIMO)
2898 printk("ENSELTIMO ");
2899 if (s & ENATNTARG)
2900 printk("ENATNTARG ");
2901 if (s & ENPHASEMIS)
2902 printk("ENPHASEMIS ");
2903 if (s & ENBUSFREE)
2904 printk("ENBUSFREE ");
2905 if (s & ENSCSIPERR)
2906 printk("ENSCSIPERR ");
2907 if (s & ENPHASECHG)
2908 printk("ENPHASECHG ");
2909 if (s & ENREQINIT)
2910 printk("ENREQINIT ");
2911 printk(")\n");
2912}
2913
2914/*
2915 * Show the command data of a command
2916 */
2917static void show_command(Scsi_Cmnd *ptr)
2918{
2919 scmd_printk(KERN_DEBUG, ptr, "%p: cmnd=(", ptr);
2920
2921 __scsi_print_command(ptr->cmnd);
2922
2923 printk(KERN_DEBUG "); request_bufflen=%d; resid=%d; phase |",
2924 scsi_bufflen(ptr), scsi_get_resid(ptr));
2925
2926 if (ptr->SCp.phase & not_issued)
2927 printk("not issued|");
2928 if (ptr->SCp.phase & selecting)
2929 printk("selecting|");
2930 if (ptr->SCp.phase & identified)
2931 printk("identified|");
2932 if (ptr->SCp.phase & disconnected)
2933 printk("disconnected|");
2934 if (ptr->SCp.phase & completed)
2935 printk("completed|");
2936 if (ptr->SCp.phase & spiordy)
2937 printk("spiordy|");
2938 if (ptr->SCp.phase & syncneg)
2939 printk("syncneg|");
2940 if (ptr->SCp.phase & aborted)
2941 printk("aborted|");
2942 if (ptr->SCp.phase & resetted)
2943 printk("resetted|");
2944 if( SCDATA(ptr) ) {
2945 printk("; next=0x%p\n", SCNEXT(ptr));
2946 } else {
2947 printk("; next=(host scribble NULL)\n");
2948 }
2949}
2950
2951/*
2952 * Dump the queued data
2953 */
2954static void show_queues(struct Scsi_Host *shpnt)
2955{
2956 Scsi_Cmnd *ptr;
2957 unsigned long flags;
2958
2959 DO_LOCK(flags);
2960 printk(KERN_DEBUG "\nqueue status:\nissue_SC:\n");
2961 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
2962 show_command(ptr);
2963 DO_UNLOCK(flags);
2964
2965 printk(KERN_DEBUG "current_SC:\n");
2966 if (CURRENT_SC)
2967 show_command(CURRENT_SC);
2968 else
2969 printk(KERN_DEBUG "none\n");
2970
2971 printk(KERN_DEBUG "disconnected_SC:\n");
2972 for (ptr = DISCONNECTED_SC; ptr; ptr = SCDATA(ptr) ? SCNEXT(ptr) : NULL)
2973 show_command(ptr);
2974
2975 disp_ports(shpnt);
2976 disp_enintr(shpnt);
2977}
2978
2979#undef SPRINTF
2980#define SPRINTF(args...) seq_printf(m, ##args)
2981
2982static void get_command(struct seq_file *m, Scsi_Cmnd * ptr)
2983{
2984 int i;
2985
2986 SPRINTF("%p: target=%d; lun=%d; cmnd=( ",
2987 ptr, ptr->device->id, ptr->device->lun);
2988
2989 for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
2990 SPRINTF("0x%02x ", ptr->cmnd[i]);
2991
2992 SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
2993 scsi_get_resid(ptr), ptr->SCp.this_residual,
2994 ptr->SCp.buffers_residual);
2995
2996 if (ptr->SCp.phase & not_issued)
2997 SPRINTF("not issued|");
2998 if (ptr->SCp.phase & selecting)
2999 SPRINTF("selecting|");
3000 if (ptr->SCp.phase & disconnected)
3001 SPRINTF("disconnected|");
3002 if (ptr->SCp.phase & aborted)
3003 SPRINTF("aborted|");
3004 if (ptr->SCp.phase & identified)
3005 SPRINTF("identified|");
3006 if (ptr->SCp.phase & completed)
3007 SPRINTF("completed|");
3008 if (ptr->SCp.phase & spiordy)
3009 SPRINTF("spiordy|");
3010 if (ptr->SCp.phase & syncneg)
3011 SPRINTF("syncneg|");
3012 SPRINTF("; next=0x%p\n", SCNEXT(ptr));
3013}
3014
3015static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
3016{
3017 int s;
3018
3019 SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
3020
3021 s = GETPORT(SCSISEQ);
3022 SPRINTF("SCSISEQ( ");
3023 if (s & TEMODEO)
3024 SPRINTF("TARGET MODE ");
3025 if (s & ENSELO)
3026 SPRINTF("SELO ");
3027 if (s & ENSELI)
3028 SPRINTF("SELI ");
3029 if (s & ENRESELI)
3030 SPRINTF("RESELI ");
3031 if (s & ENAUTOATNO)
3032 SPRINTF("AUTOATNO ");
3033 if (s & ENAUTOATNI)
3034 SPRINTF("AUTOATNI ");
3035 if (s & ENAUTOATNP)
3036 SPRINTF("AUTOATNP ");
3037 if (s & SCSIRSTO)
3038 SPRINTF("SCSIRSTO ");
3039 SPRINTF(");");
3040
3041 SPRINTF(" SCSISIG(");
3042 s = GETPORT(SCSISIG);
3043 switch (s & P_MASK) {
3044 case P_DATAO:
3045 SPRINTF("DATA OUT");
3046 break;
3047 case P_DATAI:
3048 SPRINTF("DATA IN");
3049 break;
3050 case P_CMD:
3051 SPRINTF("COMMAND");
3052 break;
3053 case P_STATUS:
3054 SPRINTF("STATUS");
3055 break;
3056 case P_MSGO:
3057 SPRINTF("MESSAGE OUT");
3058 break;
3059 case P_MSGI:
3060 SPRINTF("MESSAGE IN");
3061 break;
3062 default:
3063 SPRINTF("*invalid*");
3064 break;
3065 }
3066
3067 SPRINTF("); ");
3068
3069 SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
3070
3071 SPRINTF("SSTAT( ");
3072 s = GETPORT(SSTAT0);
3073 if (s & TARGET)
3074 SPRINTF("TARGET ");
3075 if (s & SELDO)
3076 SPRINTF("SELDO ");
3077 if (s & SELDI)
3078 SPRINTF("SELDI ");
3079 if (s & SELINGO)
3080 SPRINTF("SELINGO ");
3081 if (s & SWRAP)
3082 SPRINTF("SWRAP ");
3083 if (s & SDONE)
3084 SPRINTF("SDONE ");
3085 if (s & SPIORDY)
3086 SPRINTF("SPIORDY ");
3087 if (s & DMADONE)
3088 SPRINTF("DMADONE ");
3089
3090 s = GETPORT(SSTAT1);
3091 if (s & SELTO)
3092 SPRINTF("SELTO ");
3093 if (s & ATNTARG)
3094 SPRINTF("ATNTARG ");
3095 if (s & SCSIRSTI)
3096 SPRINTF("SCSIRSTI ");
3097 if (s & PHASEMIS)
3098 SPRINTF("PHASEMIS ");
3099 if (s & BUSFREE)
3100 SPRINTF("BUSFREE ");
3101 if (s & SCSIPERR)
3102 SPRINTF("SCSIPERR ");
3103 if (s & PHASECHG)
3104 SPRINTF("PHASECHG ");
3105 if (s & REQINIT)
3106 SPRINTF("REQINIT ");
3107 SPRINTF("); ");
3108
3109
3110 SPRINTF("SSTAT( ");
3111
3112 s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
3113
3114 if (s & TARGET)
3115 SPRINTF("TARGET ");
3116 if (s & SELDO)
3117 SPRINTF("SELDO ");
3118 if (s & SELDI)
3119 SPRINTF("SELDI ");
3120 if (s & SELINGO)
3121 SPRINTF("SELINGO ");
3122 if (s & SWRAP)
3123 SPRINTF("SWRAP ");
3124 if (s & SDONE)
3125 SPRINTF("SDONE ");
3126 if (s & SPIORDY)
3127 SPRINTF("SPIORDY ");
3128 if (s & DMADONE)
3129 SPRINTF("DMADONE ");
3130
3131 s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
3132
3133 if (s & SELTO)
3134 SPRINTF("SELTO ");
3135 if (s & ATNTARG)
3136 SPRINTF("ATNTARG ");
3137 if (s & SCSIRSTI)
3138 SPRINTF("SCSIRSTI ");
3139 if (s & PHASEMIS)
3140 SPRINTF("PHASEMIS ");
3141 if (s & BUSFREE)
3142 SPRINTF("BUSFREE ");
3143 if (s & SCSIPERR)
3144 SPRINTF("SCSIPERR ");
3145 if (s & PHASECHG)
3146 SPRINTF("PHASECHG ");
3147 if (s & REQINIT)
3148 SPRINTF("REQINIT ");
3149 SPRINTF("); ");
3150
3151 SPRINTF("SXFRCTL0( ");
3152
3153 s = GETPORT(SXFRCTL0);
3154 if (s & SCSIEN)
3155 SPRINTF("SCSIEN ");
3156 if (s & DMAEN)
3157 SPRINTF("DMAEN ");
3158 if (s & CH1)
3159 SPRINTF("CH1 ");
3160 if (s & CLRSTCNT)
3161 SPRINTF("CLRSTCNT ");
3162 if (s & SPIOEN)
3163 SPRINTF("SPIOEN ");
3164 if (s & CLRCH1)
3165 SPRINTF("CLRCH1 ");
3166 SPRINTF("); ");
3167
3168 SPRINTF("SIGNAL( ");
3169
3170 s = GETPORT(SCSISIG);
3171 if (s & SIG_ATNI)
3172 SPRINTF("ATNI ");
3173 if (s & SIG_SELI)
3174 SPRINTF("SELI ");
3175 if (s & SIG_BSYI)
3176 SPRINTF("BSYI ");
3177 if (s & SIG_REQI)
3178 SPRINTF("REQI ");
3179 if (s & SIG_ACKI)
3180 SPRINTF("ACKI ");
3181 SPRINTF("); ");
3182
3183 SPRINTF("SELID(%02x), ", GETPORT(SELID));
3184
3185 SPRINTF("STCNT(%d), ", GETSTCNT());
3186
3187 SPRINTF("SSTAT2( ");
3188
3189 s = GETPORT(SSTAT2);
3190 if (s & SOFFSET)
3191 SPRINTF("SOFFSET ");
3192 if (s & SEMPTY)
3193 SPRINTF("SEMPTY ");
3194 if (s & SFULL)
3195 SPRINTF("SFULL ");
3196 SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
3197
3198 s = GETPORT(SSTAT3);
3199 SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
3200
3201 SPRINTF("SSTAT4( ");
3202 s = GETPORT(SSTAT4);
3203 if (s & SYNCERR)
3204 SPRINTF("SYNCERR ");
3205 if (s & FWERR)
3206 SPRINTF("FWERR ");
3207 if (s & FRERR)
3208 SPRINTF("FRERR ");
3209 SPRINTF("); ");
3210
3211 SPRINTF("DMACNTRL0( ");
3212 s = GETPORT(DMACNTRL0);
3213 SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
3214 SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
3215 SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
3216 if (s & ENDMA)
3217 SPRINTF("ENDMA ");
3218 if (s & INTEN)
3219 SPRINTF("INTEN ");
3220 if (s & RSTFIFO)
3221 SPRINTF("RSTFIFO ");
3222 if (s & SWINT)
3223 SPRINTF("SWINT ");
3224 SPRINTF("); ");
3225
3226 SPRINTF("DMASTAT( ");
3227 s = GETPORT(DMASTAT);
3228 if (s & ATDONE)
3229 SPRINTF("ATDONE ");
3230 if (s & WORDRDY)
3231 SPRINTF("WORDRDY ");
3232 if (s & DFIFOFULL)
3233 SPRINTF("DFIFOFULL ");
3234 if (s & DFIFOEMP)
3235 SPRINTF("DFIFOEMP ");
3236 SPRINTF(")\n");
3237
3238 SPRINTF("enabled interrupts( ");
3239
3240 s = GETPORT(SIMODE0);
3241 if (s & ENSELDO)
3242 SPRINTF("ENSELDO ");
3243 if (s & ENSELDI)
3244 SPRINTF("ENSELDI ");
3245 if (s & ENSELINGO)
3246 SPRINTF("ENSELINGO ");
3247 if (s & ENSWRAP)
3248 SPRINTF("ENSWRAP ");
3249 if (s & ENSDONE)
3250 SPRINTF("ENSDONE ");
3251 if (s & ENSPIORDY)
3252 SPRINTF("ENSPIORDY ");
3253 if (s & ENDMADONE)
3254 SPRINTF("ENDMADONE ");
3255
3256 s = GETPORT(SIMODE1);
3257 if (s & ENSELTIMO)
3258 SPRINTF("ENSELTIMO ");
3259 if (s & ENATNTARG)
3260 SPRINTF("ENATNTARG ");
3261 if (s & ENPHASEMIS)
3262 SPRINTF("ENPHASEMIS ");
3263 if (s & ENBUSFREE)
3264 SPRINTF("ENBUSFREE ");
3265 if (s & ENSCSIPERR)
3266 SPRINTF("ENSCSIPERR ");
3267 if (s & ENPHASECHG)
3268 SPRINTF("ENPHASECHG ");
3269 if (s & ENREQINIT)
3270 SPRINTF("ENREQINIT ");
3271 SPRINTF(")\n");
3272}
3273
3274static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
3275{
3276 if(!shpnt || !buffer || length<8 || strncmp("aha152x ", buffer, 8)!=0)
3277 return -EINVAL;
3278
3279#if defined(AHA152X_DEBUG)
3280 if(length>14 && strncmp("debug ", buffer+8, 6)==0) {
3281 int debug = HOSTDATA(shpnt)->debug;
3282
3283 HOSTDATA(shpnt)->debug = simple_strtoul(buffer+14, NULL, 0);
3284
3285 printk(KERN_INFO "aha152x%d: debugging options set to 0x%04x (were 0x%04x)\n", HOSTNO, HOSTDATA(shpnt)->debug, debug);
3286 } else
3287#endif
3288#if defined(AHA152X_STAT)
3289 if(length>13 && strncmp("reset", buffer+8, 5)==0) {
3290 int i;
3291
3292 HOSTDATA(shpnt)->total_commands=0;
3293 HOSTDATA(shpnt)->disconnections=0;
3294 HOSTDATA(shpnt)->busfree_without_any_action=0;
3295 HOSTDATA(shpnt)->busfree_without_old_command=0;
3296 HOSTDATA(shpnt)->busfree_without_new_command=0;
3297 HOSTDATA(shpnt)->busfree_without_done_command=0;
3298 HOSTDATA(shpnt)->busfree_with_check_condition=0;
3299 for (i = idle; i<maxstate; i++) {
3300 HOSTDATA(shpnt)->count[i]=0;
3301 HOSTDATA(shpnt)->count_trans[i]=0;
3302 HOSTDATA(shpnt)->time[i]=0;
3303 }
3304
3305 printk(KERN_INFO "aha152x%d: stats reseted.\n", HOSTNO);
3306
3307 } else
3308#endif
3309 {
3310 return -EINVAL;
3311 }
3312
3313
3314 return length;
3315}
3316
3317static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
3318{
3319 int i;
3320 Scsi_Cmnd *ptr;
3321 unsigned long flags;
3322
3323 SPRINTF(AHA152X_REVID "\n");
3324
3325 SPRINTF("ioports 0x%04lx to 0x%04lx\n",
3326 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
3327 SPRINTF("interrupt 0x%02x\n", shpnt->irq);
3328 SPRINTF("disconnection/reconnection %s\n",
3329 RECONNECT ? "enabled" : "disabled");
3330 SPRINTF("parity checking %s\n",
3331 PARITY ? "enabled" : "disabled");
3332 SPRINTF("synchronous transfers %s\n",
3333 SYNCHRONOUS ? "enabled" : "disabled");
3334 SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
3335
3336 if(SYNCHRONOUS) {
3337 SPRINTF("synchronously operating targets (tick=50 ns):\n");
3338 for (i = 0; i < 8; i++)
3339 if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
3340 SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
3341 i,
3342 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
3343 (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
3344 HOSTDATA(shpnt)->syncrate[i] & 0x0f);
3345 }
3346#if defined(AHA152X_DEBUG)
3347#define PDEBUG(flags,txt) \
3348 if(HOSTDATA(shpnt)->debug & flags) SPRINTF("(%s) ", txt);
3349
3350 SPRINTF("enabled debugging options: ");
3351
3352 PDEBUG(debug_procinfo, "procinfo");
3353 PDEBUG(debug_queue, "queue");
3354 PDEBUG(debug_intr, "interrupt");
3355 PDEBUG(debug_selection, "selection");
3356 PDEBUG(debug_msgo, "message out");
3357 PDEBUG(debug_msgi, "message in");
3358 PDEBUG(debug_status, "status");
3359 PDEBUG(debug_cmd, "command");
3360 PDEBUG(debug_datai, "data in");
3361 PDEBUG(debug_datao, "data out");
3362 PDEBUG(debug_eh, "eh");
3363 PDEBUG(debug_locking, "locks");
3364 PDEBUG(debug_phases, "phases");
3365
3366 SPRINTF("\n");
3367#endif
3368
3369 SPRINTF("\nqueue status:\n");
3370 DO_LOCK(flags);
3371 if (ISSUE_SC) {
3372 SPRINTF("not yet issued commands:\n");
3373 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
3374 get_command(m, ptr);
3375 } else
3376 SPRINTF("no not yet issued commands\n");
3377 DO_UNLOCK(flags);
3378
3379 if (CURRENT_SC) {
3380 SPRINTF("current command:\n");
3381 get_command(m, CURRENT_SC);
3382 } else
3383 SPRINTF("no current command\n");
3384
3385 if (DISCONNECTED_SC) {
3386 SPRINTF("disconnected commands:\n");
3387 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
3388 get_command(m, ptr);
3389 } else
3390 SPRINTF("no disconnected commands\n");
3391
3392 get_ports(m, shpnt);
3393
3394#if defined(AHA152X_STAT)
3395 SPRINTF("statistics:\n"
3396 "total commands: %d\n"
3397 "disconnections: %d\n"
3398 "busfree with check condition: %d\n"
3399 "busfree without old command: %d\n"
3400 "busfree without new command: %d\n"
3401 "busfree without done command: %d\n"
3402 "busfree without any action: %d\n"
3403 "state "
3404 "transitions "
3405 "count "
3406 "time\n",
3407 HOSTDATA(shpnt)->total_commands,
3408 HOSTDATA(shpnt)->disconnections,
3409 HOSTDATA(shpnt)->busfree_with_check_condition,
3410 HOSTDATA(shpnt)->busfree_without_old_command,
3411 HOSTDATA(shpnt)->busfree_without_new_command,
3412 HOSTDATA(shpnt)->busfree_without_done_command,
3413 HOSTDATA(shpnt)->busfree_without_any_action);
3414 for(i=0; i<maxstate; i++) {
3415 SPRINTF("%-10s %-12d %-12d %-12ld\n",
3416 states[i].name,
3417 HOSTDATA(shpnt)->count_trans[i],
3418 HOSTDATA(shpnt)->count[i],
3419 HOSTDATA(shpnt)->time[i]);
3420 }
3421#endif
3422 return 0;
3423}
3424
3425static int aha152x_adjust_queue(struct scsi_device *device)
3426{
3427 blk_queue_bounce_limit(device->request_queue, BLK_BOUNCE_HIGH);
3428 return 0;
3429}
3430
3431static struct scsi_host_template aha152x_driver_template = {
3432 .module = THIS_MODULE,
3433 .name = AHA152X_REVID,
3434 .proc_name = "aha152x",
3435 .show_info = aha152x_show_info,
3436 .write_info = aha152x_set_info,
3437 .queuecommand = aha152x_queue,
3438 .eh_abort_handler = aha152x_abort,
3439 .eh_device_reset_handler = aha152x_device_reset,
3440 .eh_bus_reset_handler = aha152x_bus_reset,
3441 .eh_host_reset_handler = aha152x_host_reset,
3442 .bios_param = aha152x_biosparam,
3443 .can_queue = 1,
3444 .this_id = 7,
3445 .sg_tablesize = SG_ALL,
3446 .cmd_per_lun = 1,
3447 .use_clustering = DISABLE_CLUSTERING,
3448 .slave_alloc = aha152x_adjust_queue,
3449};
3450
3451#if !defined(PCMCIA)
3452static int setup_count;
3453static struct aha152x_setup setup[2];
3454
3455/* possible i/o addresses for the AIC-6260; default first */
3456static unsigned short ports[] = { 0x340, 0x140 };
3457
3458#if !defined(SKIP_BIOSTEST)
3459/* possible locations for the Adaptec BIOS; defaults first */
3460static unsigned int addresses[] =
3461{
3462 0xdc000, /* default first */
3463 0xc8000,
3464 0xcc000,
3465 0xd0000,
3466 0xd4000,
3467 0xd8000,
3468 0xe0000,
3469 0xeb800, /* VTech Platinum SMP */
3470 0xf0000,
3471};
3472
3473/* signatures for various AIC-6[23]60 based controllers.
3474 The point in detecting signatures is to avoid useless and maybe
3475 harmful probes on ports. I'm not sure that all listed boards pass
3476 auto-configuration. For those which fail the BIOS signature is
3477 obsolete, because user intervention to supply the configuration is
3478 needed anyway. May be an information whether or not the BIOS supports
3479 extended translation could be also useful here. */
3480static struct signature {
3481 unsigned char *signature;
3482 int sig_offset;
3483 int sig_length;
3484} signatures[] =
3485{
3486 { "Adaptec AHA-1520 BIOS", 0x102e, 21 },
3487 /* Adaptec 152x */
3488 { "Adaptec AHA-1520B", 0x000b, 17 },
3489 /* Adaptec 152x rev B */
3490 { "Adaptec AHA-1520B", 0x0026, 17 },
3491 /* Iomega Jaz Jet ISA (AIC6370Q) */
3492 { "Adaptec ASW-B626 BIOS", 0x1029, 21 },
3493 /* on-board controller */
3494 { "Adaptec BIOS: ASW-B626", 0x000f, 22 },
3495 /* on-board controller */
3496 { "Adaptec ASW-B626 S2", 0x2e6c, 19 },
3497 /* on-board controller */
3498 { "Adaptec BIOS:AIC-6360", 0x000c, 21 },
3499 /* on-board controller */
3500 { "ScsiPro SP-360 BIOS", 0x2873, 19 },
3501 /* ScsiPro-Controller */
3502 { "GA-400 LOCAL BUS SCSI BIOS", 0x102e, 26 },
3503 /* Gigabyte Local-Bus-SCSI */
3504 { "Adaptec BIOS:AVA-282X", 0x000c, 21 },
3505 /* Adaptec 282x */
3506 { "Adaptec IBM Dock II SCSI", 0x2edd, 24 },
3507 /* IBM Thinkpad Dock II */
3508 { "Adaptec BIOS:AHA-1532P", 0x001c, 22 },
3509 /* IBM Thinkpad Dock II SCSI */
3510 { "DTC3520A Host Adapter BIOS", 0x318a, 26 },
3511 /* DTC 3520A ISA SCSI */
3512};
3513#endif /* !SKIP_BIOSTEST */
3514
3515/*
3516 * Test, if port_base is valid.
3517 *
3518 */
3519static int aha152x_porttest(int io_port)
3520{
3521 int i;
3522
3523 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3524 for (i = 0; i < 16; i++)
3525 SETPORT(io_port + O_STACK, i);
3526
3527 SETPORT(io_port + O_DMACNTRL1, 0); /* reset stack pointer */
3528 for (i = 0; i < 16 && GETPORT(io_port + O_STACK) == i; i++)
3529 ;
3530
3531 return (i == 16);
3532}
3533
3534static int tc1550_porttest(int io_port)
3535{
3536 int i;
3537
3538 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3539 for (i = 0; i < 16; i++)
3540 SETPORT(io_port + O_STACK, i);
3541
3542 SETPORT(io_port + O_TC_DMACNTRL1, 0); /* reset stack pointer */
3543 for (i = 0; i < 16 && GETPORT(io_port + O_TC_STACK) == i; i++)
3544 ;
3545
3546 return (i == 16);
3547}
3548
3549
3550static int checksetup(struct aha152x_setup *setup)
3551{
3552 int i;
3553 for (i = 0; i < ARRAY_SIZE(ports) && (setup->io_port != ports[i]); i++)
3554 ;
3555
3556 if (i == ARRAY_SIZE(ports))
3557 return 0;
3558
3559 if (!request_region(setup->io_port, IO_RANGE, "aha152x")) {
3560 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup->io_port);
3561 return 0;
3562 }
3563
3564 if( aha152x_porttest(setup->io_port) ) {
3565 setup->tc1550=0;
3566 } else if( tc1550_porttest(setup->io_port) ) {
3567 setup->tc1550=1;
3568 } else {
3569 release_region(setup->io_port, IO_RANGE);
3570 return 0;
3571 }
3572
3573 release_region(setup->io_port, IO_RANGE);
3574
3575 if ((setup->irq < IRQ_MIN) || (setup->irq > IRQ_MAX))
3576 return 0;
3577
3578 if ((setup->scsiid < 0) || (setup->scsiid > 7))
3579 return 0;
3580
3581 if ((setup->reconnect < 0) || (setup->reconnect > 1))
3582 return 0;
3583
3584 if ((setup->parity < 0) || (setup->parity > 1))
3585 return 0;
3586
3587 if ((setup->synchronous < 0) || (setup->synchronous > 1))
3588 return 0;
3589
3590 if ((setup->ext_trans < 0) || (setup->ext_trans > 1))
3591 return 0;
3592
3593
3594 return 1;
3595}
3596
3597
3598static int __init aha152x_init(void)
3599{
3600 int i, j, ok;
3601#if defined(AUTOCONF)
3602 aha152x_config conf;
3603#endif
3604#ifdef __ISAPNP__
3605 struct pnp_dev *dev=NULL, *pnpdev[2] = {NULL, NULL};
3606#endif
3607
3608 if ( setup_count ) {
3609 printk(KERN_INFO "aha152x: processing commandline: ");
3610
3611 for (i = 0; i<setup_count; i++) {
3612 if (!checksetup(&setup[i])) {
3613 printk(KERN_ERR "\naha152x: %s\n", setup[i].conf);
3614 printk(KERN_ERR "aha152x: invalid line\n");
3615 }
3616 }
3617 printk("ok\n");
3618 }
3619
3620#if defined(SETUP0)
3621 if (setup_count < ARRAY_SIZE(setup)) {
3622 struct aha152x_setup override = SETUP0;
3623
3624 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3625 if (!checksetup(&override)) {
3626 printk(KERN_ERR "\naha152x: invalid override SETUP0={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3627 override.io_port,
3628 override.irq,
3629 override.scsiid,
3630 override.reconnect,
3631 override.parity,
3632 override.synchronous,
3633 override.delay,
3634 override.ext_trans);
3635 } else
3636 setup[setup_count++] = override;
3637 }
3638 }
3639#endif
3640
3641#if defined(SETUP1)
3642 if (setup_count < ARRAY_SIZE(setup)) {
3643 struct aha152x_setup override = SETUP1;
3644
3645 if (setup_count == 0 || (override.io_port != setup[0].io_port)) {
3646 if (!checksetup(&override)) {
3647 printk(KERN_ERR "\naha152x: invalid override SETUP1={0x%x,%d,%d,%d,%d,%d,%d,%d}\n",
3648 override.io_port,
3649 override.irq,
3650 override.scsiid,
3651 override.reconnect,
3652 override.parity,
3653 override.synchronous,
3654 override.delay,
3655 override.ext_trans);
3656 } else
3657 setup[setup_count++] = override;
3658 }
3659 }
3660#endif
3661
3662#if defined(MODULE)
3663 if (setup_count<ARRAY_SIZE(setup) && (aha152x[0]!=0 || io[0]!=0 || irq[0]!=0)) {
3664 if(aha152x[0]!=0) {
3665 setup[setup_count].conf = "";
3666 setup[setup_count].io_port = aha152x[0];
3667 setup[setup_count].irq = aha152x[1];
3668 setup[setup_count].scsiid = aha152x[2];
3669 setup[setup_count].reconnect = aha152x[3];
3670 setup[setup_count].parity = aha152x[4];
3671 setup[setup_count].synchronous = aha152x[5];
3672 setup[setup_count].delay = aha152x[6];
3673 setup[setup_count].ext_trans = aha152x[7];
3674#if defined(AHA152X_DEBUG)
3675 setup[setup_count].debug = aha152x[8];
3676#endif
3677 } else if(io[0]!=0 || irq[0]!=0) {
3678 if(io[0]!=0) setup[setup_count].io_port = io[0];
3679 if(irq[0]!=0) setup[setup_count].irq = irq[0];
3680
3681 setup[setup_count].scsiid = scsiid[0];
3682 setup[setup_count].reconnect = reconnect[0];
3683 setup[setup_count].parity = parity[0];
3684 setup[setup_count].synchronous = sync[0];
3685 setup[setup_count].delay = delay[0];
3686 setup[setup_count].ext_trans = exttrans[0];
3687#if defined(AHA152X_DEBUG)
3688 setup[setup_count].debug = debug[0];
3689#endif
3690 }
3691
3692 if (checksetup(&setup[setup_count]))
3693 setup_count++;
3694 else
3695 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",
3696 setup[setup_count].io_port,
3697 setup[setup_count].irq,
3698 setup[setup_count].scsiid,
3699 setup[setup_count].reconnect,
3700 setup[setup_count].parity,
3701 setup[setup_count].synchronous,
3702 setup[setup_count].delay,
3703 setup[setup_count].ext_trans);
3704 }
3705
3706 if (setup_count<ARRAY_SIZE(setup) && (aha152x1[0]!=0 || io[1]!=0 || irq[1]!=0)) {
3707 if(aha152x1[0]!=0) {
3708 setup[setup_count].conf = "";
3709 setup[setup_count].io_port = aha152x1[0];
3710 setup[setup_count].irq = aha152x1[1];
3711 setup[setup_count].scsiid = aha152x1[2];
3712 setup[setup_count].reconnect = aha152x1[3];
3713 setup[setup_count].parity = aha152x1[4];
3714 setup[setup_count].synchronous = aha152x1[5];
3715 setup[setup_count].delay = aha152x1[6];
3716 setup[setup_count].ext_trans = aha152x1[7];
3717#if defined(AHA152X_DEBUG)
3718 setup[setup_count].debug = aha152x1[8];
3719#endif
3720 } else if(io[1]!=0 || irq[1]!=0) {
3721 if(io[1]!=0) setup[setup_count].io_port = io[1];
3722 if(irq[1]!=0) setup[setup_count].irq = irq[1];
3723
3724 setup[setup_count].scsiid = scsiid[1];
3725 setup[setup_count].reconnect = reconnect[1];
3726 setup[setup_count].parity = parity[1];
3727 setup[setup_count].synchronous = sync[1];
3728 setup[setup_count].delay = delay[1];
3729 setup[setup_count].ext_trans = exttrans[1];
3730#if defined(AHA152X_DEBUG)
3731 setup[setup_count].debug = debug[1];
3732#endif
3733 }
3734 if (checksetup(&setup[setup_count]))
3735 setup_count++;
3736 else
3737 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",
3738 setup[setup_count].io_port,
3739 setup[setup_count].irq,
3740 setup[setup_count].scsiid,
3741 setup[setup_count].reconnect,
3742 setup[setup_count].parity,
3743 setup[setup_count].synchronous,
3744 setup[setup_count].delay,
3745 setup[setup_count].ext_trans);
3746 }
3747#endif
3748
3749#ifdef __ISAPNP__
3750 for(i=0; setup_count<ARRAY_SIZE(setup) && id_table[i].vendor; i++) {
3751 while ( setup_count<ARRAY_SIZE(setup) &&
3752 (dev=pnp_find_dev(NULL, id_table[i].vendor, id_table[i].function, dev)) ) {
3753 if (pnp_device_attach(dev) < 0)
3754 continue;
3755
3756 if (pnp_activate_dev(dev) < 0) {
3757 pnp_device_detach(dev);
3758 continue;
3759 }
3760
3761 if (!pnp_port_valid(dev, 0)) {
3762 pnp_device_detach(dev);
3763 continue;
3764 }
3765
3766 if (setup_count==1 && pnp_port_start(dev, 0)==setup[0].io_port) {
3767 pnp_device_detach(dev);
3768 continue;
3769 }
3770
3771 setup[setup_count].io_port = pnp_port_start(dev, 0);
3772 setup[setup_count].irq = pnp_irq(dev, 0);
3773 setup[setup_count].scsiid = 7;
3774 setup[setup_count].reconnect = 1;
3775 setup[setup_count].parity = 1;
3776 setup[setup_count].synchronous = 1;
3777 setup[setup_count].delay = DELAY_DEFAULT;
3778 setup[setup_count].ext_trans = 0;
3779#if defined(AHA152X_DEBUG)
3780 setup[setup_count].debug = DEBUG_DEFAULT;
3781#endif
3782#if defined(__ISAPNP__)
3783 pnpdev[setup_count] = dev;
3784#endif
3785 printk (KERN_INFO
3786 "aha152x: found ISAPnP adapter at io=0x%03x, irq=%d\n",
3787 setup[setup_count].io_port, setup[setup_count].irq);
3788 setup_count++;
3789 }
3790 }
3791#endif
3792
3793#if defined(AUTOCONF)
3794 if (setup_count<ARRAY_SIZE(setup)) {
3795#if !defined(SKIP_BIOSTEST)
3796 ok = 0;
3797 for (i = 0; i < ARRAY_SIZE(addresses) && !ok; i++) {
3798 void __iomem *p = ioremap(addresses[i], 0x4000);
3799 if (!p)
3800 continue;
3801 for (j = 0; j<ARRAY_SIZE(signatures) && !ok; j++)
3802 ok = check_signature(p + signatures[j].sig_offset,
3803 signatures[j].signature, signatures[j].sig_length);
3804 iounmap(p);
3805 }
3806 if (!ok && setup_count == 0)
3807 return -ENODEV;
3808
3809 printk(KERN_INFO "aha152x: BIOS test: passed, ");
3810#else
3811 printk(KERN_INFO "aha152x: ");
3812#endif /* !SKIP_BIOSTEST */
3813
3814 ok = 0;
3815 for (i = 0; i < ARRAY_SIZE(ports) && setup_count < 2; i++) {
3816 if ((setup_count == 1) && (setup[0].io_port == ports[i]))
3817 continue;
3818
3819 if (!request_region(ports[i], IO_RANGE, "aha152x")) {
3820 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", ports[i]);
3821 continue;
3822 }
3823
3824 if (aha152x_porttest(ports[i])) {
3825 setup[setup_count].tc1550 = 0;
3826
3827 conf.cf_port =
3828 (GETPORT(ports[i] + O_PORTA) << 8) + GETPORT(ports[i] + O_PORTB);
3829 } else if (tc1550_porttest(ports[i])) {
3830 setup[setup_count].tc1550 = 1;
3831
3832 conf.cf_port =
3833 (GETPORT(ports[i] + O_TC_PORTA) << 8) + GETPORT(ports[i] + O_TC_PORTB);
3834 } else {
3835 release_region(ports[i], IO_RANGE);
3836 continue;
3837 }
3838
3839 release_region(ports[i], IO_RANGE);
3840
3841 ok++;
3842 setup[setup_count].io_port = ports[i];
3843 setup[setup_count].irq = IRQ_MIN + conf.cf_irq;
3844 setup[setup_count].scsiid = conf.cf_id;
3845 setup[setup_count].reconnect = conf.cf_tardisc;
3846 setup[setup_count].parity = !conf.cf_parity;
3847 setup[setup_count].synchronous = conf.cf_syncneg;
3848 setup[setup_count].delay = DELAY_DEFAULT;
3849 setup[setup_count].ext_trans = 0;
3850#if defined(AHA152X_DEBUG)
3851 setup[setup_count].debug = DEBUG_DEFAULT;
3852#endif
3853 setup_count++;
3854
3855 }
3856
3857 if (ok)
3858 printk("auto configuration: ok, ");
3859 }
3860#endif
3861
3862 printk("%d controller(s) configured\n", setup_count);
3863
3864 for (i=0; i<setup_count; i++) {
3865 if ( request_region(setup[i].io_port, IO_RANGE, "aha152x") ) {
3866 struct Scsi_Host *shpnt = aha152x_probe_one(&setup[i]);
3867
3868 if( !shpnt ) {
3869 release_region(setup[i].io_port, IO_RANGE);
3870#if defined(__ISAPNP__)
3871 } else if( pnpdev[i] ) {
3872 HOSTDATA(shpnt)->pnpdev=pnpdev[i];
3873 pnpdev[i]=NULL;
3874#endif
3875 }
3876 } else {
3877 printk(KERN_ERR "aha152x: io port 0x%x busy.\n", setup[i].io_port);
3878 }
3879
3880#if defined(__ISAPNP__)
3881 if( pnpdev[i] )
3882 pnp_device_detach(pnpdev[i]);
3883#endif
3884 }
3885
3886 return 0;
3887}
3888
3889static void __exit aha152x_exit(void)
3890{
3891 struct aha152x_hostdata *hd, *tmp;
3892
3893 list_for_each_entry_safe(hd, tmp, &aha152x_host_list, host_list) {
3894 struct Scsi_Host *shost = container_of((void *)hd, struct Scsi_Host, hostdata);
3895
3896 aha152x_release(shost);
3897 }
3898}
3899
3900module_init(aha152x_init);
3901module_exit(aha152x_exit);
3902
3903#if !defined(MODULE)
3904static int __init aha152x_setup(char *str)
3905{
3906#if defined(AHA152X_DEBUG)
3907 int ints[11];
3908#else
3909 int ints[10];
3910#endif
3911 get_options(str, ARRAY_SIZE(ints), ints);
3912
3913 if(setup_count>=ARRAY_SIZE(setup)) {
3914 printk(KERN_ERR "aha152x: you can only configure up to two controllers\n");
3915 return 1;
3916 }
3917
3918 setup[setup_count].conf = str;
3919 setup[setup_count].io_port = ints[0] >= 1 ? ints[1] : 0x340;
3920 setup[setup_count].irq = ints[0] >= 2 ? ints[2] : 11;
3921 setup[setup_count].scsiid = ints[0] >= 3 ? ints[3] : 7;
3922 setup[setup_count].reconnect = ints[0] >= 4 ? ints[4] : 1;
3923 setup[setup_count].parity = ints[0] >= 5 ? ints[5] : 1;
3924 setup[setup_count].synchronous = ints[0] >= 6 ? ints[6] : 1;
3925 setup[setup_count].delay = ints[0] >= 7 ? ints[7] : DELAY_DEFAULT;
3926 setup[setup_count].ext_trans = ints[0] >= 8 ? ints[8] : 0;
3927#if defined(AHA152X_DEBUG)
3928 setup[setup_count].debug = ints[0] >= 9 ? ints[9] : DEBUG_DEFAULT;
3929 if (ints[0] > 9) {
3930 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3931 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>[,<DEBUG>]]]]]]]]\n");
3932#else
3933 if (ints[0] > 8) { /*}*/
3934 printk(KERN_NOTICE "aha152x: usage: aha152x=<IOBASE>[,<IRQ>[,<SCSI ID>"
3935 "[,<RECONNECT>[,<PARITY>[,<SYNCHRONOUS>[,<DELAY>[,<EXT_TRANS>]]]]]]]\n");
3936#endif
3937 } else {
3938 setup_count++;
3939 return 0;
3940 }
3941
3942 return 1;
3943}
3944__setup("aha152x=", aha152x_setup);
3945#endif
3946
3947#endif /* !PCMCIA */