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