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